void
CommandSender::sendToServer( const int profileId, const CliOptions& options )
{
ENTER()(profileId)(options);
QString uname = qgetenv( "USER" ); // UNIX
if( uname.isEmpty() )
uname = qgetenv( "USERNAME" ); // Windows
QString serverName = QString("redtimer-%1-%2").arg(uname).arg(profileId);
DEBUG()(serverName);
QLocalSocket* socket = new QLocalSocket( this );
sockets_.insert( socket, true );
connect( socket, &QLocalSocket::connected, [=](){ sendToSocket(socket, options); } );
connect( socket, &QLocalSocket::disconnected, [=](){ deleteSocket(socket); } );
socket->connectToServer( serverName, QIODevice::ReadWrite );
if( !socket->waitForConnected() )
deleteSocket( socket );
RETURN();
}
void ApplicationCore::slotHandleUniqueApplicationConnection()
{
QLocalSocket *socket = m_uniqueApplicationServer.nextPendingConnection();
connect(socket, &QLocalSocket::readyRead, socket, [this, socket](){
if (!socket->canReadLine())
return;
while (socket->canReadLine()) {
const QByteArray data = socket->readLine().trimmed();
if (data.startsWith(StartTaskCommand)) {
bool ok = true;
const TaskId id = data.mid(StartTaskCommand.length()).toInt(&ok);
if (ok) {
m_timeTracker.slotStartEvent(id);
} else {
qWarning() << "Received invalid argument:" << data;
}
} else if (data.startsWith(RaiseWindowCommand)) {
// nothing to do, see below
}
}
socket->deleteLater();
showMainWindow(ApplicationCore::ShowMode::ShowAndRaise);
});
}
bool ServerCatchcopy::listen()
{
QLocalSocket socketTestConnection;
pathSocket=ExtraSocketCatchcopy::pathSocket();
socketTestConnection.connectToServer(pathSocket);
if(socketTestConnection.waitForConnected(CATCHCOPY_COMMUNICATION_TIMEOUT))
{
error_string="Other server is listening";
emit error(error_string);
return false;
}
else
{
server.removeServer(pathSocket);
if(server.listen(pathSocket))
return true;
else
{
error_string=QString("Unable to listen %1: %2").arg(pathSocket).arg(server.errorString());
emit error(error_string);
return false;
}
}
}
void Server::onNewConnection()
{
QLocalSocket* socket = m_server->nextPendingConnection();
if (!socket) {
log("No pending client connections!", LogError);
} else if ( socket->state() != QLocalSocket::ConnectedState ) {
log("Client is not connected!", LogError);
socket->deleteLater();
} else {
QScopedPointer<ClientSocket> clientSocket( new ClientSocket(socket) );
const Arguments args = clientSocket->readArguments();
if ( !args.isEmpty() ) {
++m_socketCount;
connect( clientSocket.data(), SIGNAL(destroyed()),
this, SLOT(onSocketClosed()) );
connect( this, SIGNAL(destroyed()),
clientSocket.data(), SLOT(close()) );
connect( this, SIGNAL(destroyed()),
clientSocket.data(), SLOT(deleteAfterDisconnected()) );
emit newConnection( args, clientSocket.take() );
}
}
}
bool GUISingleApplication::sendMessage(const QByteArray &message, int timeout)
{
QLocalSocket socket;
bool connected = false;
for(int i = 0; i < 2; i++) {
socket.connectToServer(d_ptr->serverName);
connected = socket.waitForConnected(timeout/2);
if (connected || i > 0)
break;
int ms = 250;
#if defined(Q_OS_WIN)
Sleep(DWORD(ms));
#else
usleep(ms*1000);
#endif
}
if (!connected)
return false;
QDataStream ds(&socket);
ds << message;
socket.waitForBytesWritten(timeout);
return true;
}
void BrowserApplication::newLocalSocketConnection()
{
QLocalSocket *socket = m_localServer->nextPendingConnection();
if (!socket)
return;
socket->waitForReadyRead(1000);
QTextStream stream(socket);
QString url;
stream >> url;
if (!url.isEmpty()) {
QSettings settings;
settings.beginGroup(QLatin1String("general"));
int openLinksIn = settings.value(QLatin1String("openLinksIn"), 0).toInt();
settings.endGroup();
if (openLinksIn == 1)
newMainWindow();
else
mainWindow()->tabWidget()->newTab();
openUrl(url);
}
delete socket;
mainWindow()->raise();
mainWindow()->activateWindow();
}
RKGraphicsDeviceBackendTransmitter* RKGraphicsDeviceBackendTransmitter::instance () {
if (_instance) return _instance;
RK_TRACE (GRAPHICS_DEVICE);
QLocalSocket *con = new QLocalSocket ();
con->connectToServer (RKRBackendProtocolBackend::rkdServerName ());
con->waitForConnected (2000);
if (con->state () == QLocalSocket::ConnectedState) {
con->write (RKRBackendTransmitter::instance ()->connectionToken ().toLocal8Bit ().data ());
con->write ("\n");
con->waitForBytesWritten (1000);
_instance = new RKGraphicsDeviceBackendTransmitter (con, true);
return _instance;
}
return 0;
}
bool QtLocalPeer::sendMessage(const QString& message, int timeout)
{
if(!isClient())
{
return false;
}
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(timeout / 2);
if(connOk || i)
{
break;
}
int ms = 250;
#if defined(Q_OS_WIN)
Sleep(DWORD (ms));
#else
struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
nanosleep(&ts, NULL);
#endif
}
if(!connOk)
{
return false;
}
QByteArray uMsg(message.toUtf8());
QDataStream ds(&socket);
ds.writeBytes(uMsg.constData(), uMsg.size());
bool res = socket.waitForBytesWritten(timeout);
if(res)
{
res &= socket.waitForReadyRead(timeout); // wait for ack
if(res)
{
res &= (socket.read(qstrlen(ack)) == ack);
}
}
return res;
}
bool Application::IsAlreadyRunning () const
{
QLocalSocket socket;
socket.connectToServer (GetSocketName ());
if (socket.waitForConnected () ||
socket.state () == QLocalSocket::ConnectedState)
{
QByteArray toSend;
{
QDataStream out (&toSend, QIODevice::WriteOnly);
out << Arguments_;
}
socket.write (toSend);
socket.disconnectFromServer ();
socket.waitForDisconnected ();
return true;
}
else
{
switch (socket.error ())
{
case QLocalSocket::ServerNotFoundError:
case QLocalSocket::ConnectionRefusedError:
break;
default:
qWarning () << Q_FUNC_INFO
<< "socket error"
<< socket.error ();
return true;
}
}
// Clear any halted servers and their messages
QLocalServer::removeServer (GetSocketName ());
return false;
}
int main(int argc, char *argv[])
{
#if QT_NO_DEBUG
QLocalSocket socket;
socket.connectToServer(SERVER);
if(socket.waitForConnected(1000))
{
if (argc == 2)
{
socket.write(argv[1]);
socket.flush();
socket.waitForBytesWritten();
}
socket.disconnectFromServer();
exit(0);
}
else
{
if (argc != 1)
exit(0);
}
#endif
QApplication a(argc, argv);
MainWindow w;
QTranslator translator ;
translator.load("/usr/share/qt/translations/qt_cs");
a.installTranslator(&translator);
//w.show();
return a.exec();
}
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)
}
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)
}
bool mASocketManager::openFileOnRemote(const QString &_path)
{
bool r = false;
QString path = QFileInfo(_path).canonicalFilePath();
path.append('\n');
QLocalSocket socket;
socket.connectToServer(MA_LOCAL_SERVER_NAME);
if(socket.waitForConnected(MAX_TIMEOUT_CLIENT))
{
socket.write(path.toUtf8());
socket.flush();
socket.waitForBytesWritten(MAX_TIMEOUT_CLIENT);
r = true;
}
socket.close();
return r;
}
void SocketExternalInstance::loadFile(const QString &file_name) const
{
#ifdef _WIN32
::AllowSetForegroundWindow(-1);
#endif
QLocalSocket socket;
socket.connectToServer(GLOG_SERVICE_NAME);
if (!socket.waitForConnected(1000)) {
LOG( logERROR ) << "Failed to connect to socket";
return;
}
socket.write(file_name.toUtf8());
if (!socket.waitForBytesWritten(1000)) {
LOG( logERROR ) << "Failed to send filename";
}
socket.close();
}
AuthorizationRecord QJsonUIDAuthority::clientConnected(QJsonStream *stream)
{
AuthorizationRecord authRecord;
authRecord.state = QJsonAuthority::StateNotAuthorized;
if (!stream)
return authRecord;
QLocalSocket *socket = qobject_cast<QLocalSocket*>(stream->device());
if (!socket)
return authRecord;
if (socket->socketDescriptor() == (qintptr)-1) {
qWarning() << Q_FUNC_INFO << "no socket descriptor available for connection" << socket;
return authRecord;
}
uid_t euid;
#if defined(Q_OS_MAC)
gid_t egid;
if (::getpeereid(socket->socketDescriptor(), &euid, &egid) != 0) {
qWarning() << "getpeereid failed with errcode" << errno << socket->socketDescriptor();
return authRecord;
}
#else
// Check the UID table and return Authorized if appropriate.
struct ucred cr;
socklen_t len = sizeof(struct ucred);
if (::getsockopt(socket->socketDescriptor(), SOL_SOCKET, SO_PEERCRED, &cr, &len) != 0) {
qWarning() << "getsockopt failed with errcode" << errno << socket->socketDescriptor();
return authRecord;
}
euid = cr.uid;
#endif
if (m_nameForUid.contains(euid)) {
authRecord.identifier = m_nameForUid.value(euid);
authRecord.state = StateAuthorized;
}
return authRecord;
}
bool Application::sendRaiseRequest()
{
if (!d_ptr->isRunning)
return false;
QLocalSocket localSocket;
localSocket.connectToServer(GUI_APPLICATION_SHARED_MEMORY_KEY, QIODevice::WriteOnly);
if (!localSocket.waitForConnected(GUI_APPLICATION_LOCAL_SOCKET_TIMEOUT))
return false;
localSocket.write(QString("raise").toUtf8());
if (!localSocket.waitForBytesWritten(GUI_APPLICATION_LOCAL_SOCKET_TIMEOUT))
return false;
localSocket.disconnectFromServer();
return true;
}
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)
}
/**
* Sets in motion the communication necessary to ensure that only one instance
* survives.
* @returns true if a single instance is assured, false if it was not possible
* to enforce the policy
*/
bool InstanceManager::ensureSingleInstance(ResolutionScheme scheme)
{
// If the server exists, it's because we're already the dominant instance
if (mServer) {
return true;
}
QLocalSocket socket;
socket.connectToServer(mKey);
if (!socket.waitForConnected(10000)) {
// No remote server? Let's try starting our own.
startServer();
return false;
}
switch (scheme) {
case ThisInstanceWins:
tellServerToQuit(&socket);
break;
case HighestVersionWins:
default:
QTextStream stream(&socket);
stream << "version\n";
stream.flush();
socket.waitForReadyRead();
QString remoteVersion = stream.readLine();
if (VersionNumber(remoteVersion) < VersionNumber(APP_VERSION)) {
tellServerToQuit(&socket);
startServer();
} else {
QTimer::singleShot(0, qApp, SLOT(quit()));
}
break;
}
socket.disconnectFromServer();
socket.waitForDisconnected();
return true;
}
void GPUSiftClient::operator ()(const cv::Mat1b &img,
const cv::Mat &mask,
std::vector<cv::KeyPoint> &keypoints,
std::vector<float> &descriptors) const
{
QLocalSocket socket;
socket.connectToServer("nestk_sift_gpu");
if (!socket.waitForConnected(1000))
{
ntk_dbg(0) << "Could not connect to GPU SIFT server!";
keypoints.clear();
descriptors.clear();
return;
}
// Send image
QDataStream stream(&socket);
ntk_dbg(2) << "Sending " << img.rows << " " << img.cols;
stream << (qint32)img.rows << (qint32)img.cols;
int num_bytes = stream.writeRawData((const char*)img.data, img.rows*img.cols);
ntk_assert(num_bytes == img.rows*img.cols, "Could not send all data");
// Read keypoints
socket.waitForReadyRead();
qint32 num_features = -1;
stream >> num_features;
ntk_dbg_print(num_features, 2);
keypoints.resize(num_features);
readFullRawData(socket, stream, (char*)&keypoints[0], num_features*sizeof(KeyPoint));
ntk_assert(stream.status() == QDataStream::Ok, "Bad transmission.");
descriptors.resize(num_features*descriptorSize());
readFullRawData(socket, stream, (char*)&descriptors[0],
num_features*descriptorSize()*sizeof(float));
ntk_assert(stream.status() == QDataStream::Ok, "Bad transmission.");
stream << (qint32) 42;
socket.waitForBytesWritten();
socket.disconnectFromServer();
}
unsigned int LocalPeer::get_hwnd_and_activate()
{
unsigned int hwnd = 0;
#ifdef _WIN32
QLocalSocket socket;
bool connOk = false;
int timeout = 5000;
for(int i = 0; i < 2; i++)
{
socket.connectToServer(socket_name_);
connOk = socket.waitForConnected(timeout/2);
if (connOk || i)
break;
int ms = 250;
Sleep(DWORD(ms));
}
if (!connOk)
return false;
QByteArray uMsg((QString(crossprocess_message_get_hwnd_activate)).toUtf8());
QDataStream ds(&socket);
ds.writeBytes(uMsg.constData(), uMsg.size());
if (socket.waitForBytesWritten(timeout))
{
if (socket.waitForReadyRead(timeout))
{
QByteArray data_read = socket.readAll();
if (data_read.size() == sizeof(hwnd))
{
hwnd = *(unsigned int*) data_read.data();
}
}
}
#endif _WIN32
return hwnd;
}
QString ControlPeer::sendRawMessage(const QString & msg, int timeout)
{
if (mode() != ModeClient) {
p->error = NotInClientModeError;
return QString();
}
QString controlSocketPath = Guzum::Config::controlSocketPath();
QLocalSocket socket;
bool res = false;
socket.connectToServer(controlSocketPath);
res = socket.waitForConnected(timeout);
if (!res) {
p->error = ReadFailedError;
return QString();
}
QByteArray bytes(msg.toUtf8());
QByteArray responseBytes;
QDataStream ds(&socket);
ds.writeBytes(bytes.constData(), bytes.size());
res = socket.waitForBytesWritten(timeout);
if (res) {
res &= socket.waitForReadyRead(timeout); // wait for ack
if (res) {
responseBytes = socket.read(qstrlen(ACK));
res &= (responseBytes == ACK);
}
}
if (!res) {
p->error = ReadFailedError;
return QString();
}
p->error = NoError;
return QString::fromUtf8(responseBytes.constData());
}
int main(int argc, char *argv[])
{
Local a(argc, argv);
int single;
if ((single = Config::getValue("/Interface/Single", 1))){
QLocalSocket socket;
socket.connectToServer("BiliLocalInstance");
if (socket.waitForConnected()){
QDataStream s(&socket);
s << a.arguments().mid(1);
socket.waitForBytesWritten();
return 0;
}
}
loadTranslator();
setDefaultFont();
setToolTipBase();
Interface w;
Plugin::loadPlugins();
if (!w.testAttribute(Qt::WA_WState_ExplicitShowHide)){
w.show();
}
w.tryLocal(a.arguments().mid(1));
QLocalServer *server = nullptr;
if (single){
server = new QLocalServer(lApp);
server->listen("BiliLocalInstance");
QObject::connect(server, &QLocalServer::newConnection, [&](){
QLocalSocket *r = server->nextPendingConnection();
r->waitForReadyRead();
QDataStream s(r);
QStringList args;
s >> args;
delete r;
w.tryLocal(args);
});
}
int main(int argc, const char* argv[]) {
disableQtBearerPoll(); // Fixes wifi ping spikes
QString applicationName = "High Fidelity Interface - " + qgetenv("USERNAME");
bool instanceMightBeRunning = true;
#ifdef Q_OS_WIN
// Try to create a shared memory block - if it can't be created, there is an instance of
// interface already running. We only do this on Windows for now because of the potential
// for crashed instances to leave behind shared memory instances on unix.
QSharedMemory sharedMemory { applicationName };
instanceMightBeRunning = !sharedMemory.create(1, QSharedMemory::ReadOnly);
#endif
if (instanceMightBeRunning) {
// Try to connect and send message to existing interface instance
QLocalSocket socket;
socket.connectToServer(applicationName);
static const int LOCAL_SERVER_TIMEOUT_MS = 500;
// Try to connect - if we can't connect, interface has probably just gone down
if (socket.waitForConnected(LOCAL_SERVER_TIMEOUT_MS)) {
QStringList arguments;
for (int i = 0; i < argc; ++i) {
arguments << argv[i];
}
QCommandLineParser parser;
QCommandLineOption urlOption("url", "", "value");
parser.addOption(urlOption);
parser.process(arguments);
if (parser.isSet(urlOption)) {
QUrl url = QUrl(parser.value(urlOption));
if (url.isValid() && url.scheme() == HIFI_URL_SCHEME) {
qDebug() << "Writing URL to local socket";
socket.write(url.toString().toUtf8());
if (!socket.waitForBytesWritten(5000)) {
qDebug() << "Error writing URL to local socket";
}
}
}
socket.close();
qDebug() << "Interface instance appears to be running, exiting";
return EXIT_SUCCESS;
}
#ifdef Q_OS_WIN
return EXIT_SUCCESS;
#endif
}
// Check OpenGL version.
// This is done separately from the main Application so that start-up and shut-down logic within the main Application is
// not made more complicated than it already is.
{
OpenGLVersionChecker openGLVersionChecker(argc, const_cast<char**>(argv));
if (!openGLVersionChecker.isValidVersion()) {
qCDebug(interfaceapp, "Early exit due to OpenGL version.");
return 0;
}
}
QElapsedTimer startupTime;
startupTime.start();
// Debug option to demonstrate that the client's local time does not
// need to be in sync with any other network node. This forces clock
// skew for the individual client
const char* CLOCK_SKEW = "--clockSkew";
const char* clockSkewOption = getCmdOption(argc, argv, CLOCK_SKEW);
if (clockSkewOption) {
int clockSkew = atoi(clockSkewOption);
usecTimestampNowForceClockSkew(clockSkew);
qCDebug(interfaceapp, "clockSkewOption=%s clockSkew=%d", clockSkewOption, clockSkew);
}
// Oculus initialization MUST PRECEDE OpenGL context creation.
// The nature of the Application constructor means this has to be either here,
// or in the main window ctor, before GL startup.
Application::initPlugins();
int exitCode;
{
QSettings::setDefaultFormat(QSettings::IniFormat);
Application app(argc, const_cast<char**>(argv), startupTime);
// Setup local server
QLocalServer server { &app };
// We failed to connect to a local server, so we remove any existing servers.
server.removeServer(applicationName);
server.listen(applicationName);
QObject::connect(&server, &QLocalServer::newConnection, &app, &Application::handleLocalServerConnection);
QTranslator translator;
translator.load("i18n/interface_en");
app.installTranslator(&translator);
qCDebug(interfaceapp, "Created QT Application.");
exitCode = app.exec();
server.close();
}
Application::shutdownPlugins();
qCDebug(interfaceapp, "Normal exit.");
return exitCode;
}
RunControl *WinRtDebugSupport::createDebugRunControl(WinRtRunConfiguration *runConfig,
Core::Id mode,
QString *errorMessage)
{
// FIXME: This is just working for local debugging;
using namespace Debugger;
DebuggerStartParameters params;
params.startMode = AttachExternal;
// The first Thread needs to be resumed manually.
params.commandsAfterConnect = "~0 m";
QFileInfo debuggerHelper(QCoreApplication::applicationDirPath()
+ QLatin1String("/winrtdebughelper.exe"));
if (!debuggerHelper.isExecutable()) {
*errorMessage = tr("The WinRT debugging helper is missing from your Qt Creator "
"installation. It was assumed to be located at %1").arg(
debuggerHelper.absoluteFilePath());
return 0;
}
if (useQmlDebugging(runConfig)) {
quint16 qmlDebugPort = 0;
if (!getFreePort(qmlDebugPort, errorMessage))
return 0;
runConfig->setArguments(runConfig->arguments() + QLatin1Char(' ')
+ QmlDebug::qmlDebugTcpArguments(QmlDebug::QmlDebuggerServices, qmlDebugPort));
params.qmlServerAddress = QHostAddress::LocalHost;
params.qmlServerPort = qmlDebugPort;
}
WinRtRunnerHelper *runner = new WinRtRunnerHelper(runConfig, errorMessage);
if (!errorMessage->isEmpty())
return 0;
QLocalServer server;
server.listen(QLatin1String("QtCreatorWinRtDebugPIDPipe"));
runner->debug(debuggerHelper.absoluteFilePath());
if (!runner->waitForStarted()) {
*errorMessage = tr("Cannot start the WinRT Runner Tool.");
return 0;
}
if (!server.waitForNewConnection(10000)) {
*errorMessage = tr("Cannot establish connection to the WinRT debugging helper.");
return 0;
}
while (server.hasPendingConnections()) {
QLocalSocket *connection = server.nextPendingConnection();
if (connection->waitForReadyRead(1000)) {
const QByteArray &output = connection->readAll();
QList<QByteArray> arg = output.split(':');
if (arg.first() == "PID") {
bool ok =false;
params.attachPID = arg.last().toInt(&ok);
if (!ok) {
*errorMessage = tr("Cannot extract the PID from the WinRT debugging helper. "
"(output: %1)").arg(QString::fromLocal8Bit(output));
return 0;
}
server.close();
Debugger::DebuggerRunControl *debugRunControl
= createDebuggerRunControl(params, runConfig, errorMessage, mode);
runner->setDebugRunControl(debugRunControl);
new WinRtDebugSupport(debugRunControl, runner);
return debugRunControl;
}
}
}
server.close();
*errorMessage = tr("Cannot create an appropriate run control for "
"the current run configuration.");
return 0;
}
TSBrowserApplication::TSBrowserApplication(int &argc, char **argv)
: QApplication(argc, argv)
, m_localServer(0)
, bOpenLinkInTab(false)
{
QCoreApplication::setOrganizationName(QLatin1String("IJAB"));
QCoreApplication::setApplicationName(QLatin1String("SpeechNav"));
QCoreApplication::setApplicationVersion(QLatin1String("1.0.0"));
#ifdef Q_WS_QWS
// Use a different server name for QWS so we can run an X11
// browser and a QWS browser in parallel on the same machine for
// debugging
QString serverName = QCoreApplication::applicationName() + QLatin1String("_qws");
#else
QString serverName = QCoreApplication::applicationName();
#endif
QLocalSocket socket;
socket.connectToServer(serverName);
if (socket.waitForConnected(500)) {
QTextStream stream(&socket);
QStringList args = QCoreApplication::arguments();
if (args.count() > 1)
stream << args.last();
else
stream << QString();
stream.flush();
socket.waitForBytesWritten();
return;
}
#if defined(Q_WS_MAC)
QApplication::setQuitOnLastWindowClosed(false);
#else
QApplication::setQuitOnLastWindowClosed(true);
#endif
m_localServer = new QLocalServer(this);
connect(m_localServer, SIGNAL(newConnection()),
this, SLOT(newLocalSocketConnection()));
if (!m_localServer->listen(serverName)) {
if (m_localServer->serverError() == QAbstractSocket::AddressInUseError
&& QFile::exists(m_localServer->serverName())) {
QFile::remove(m_localServer->serverName());
m_localServer->listen(serverName);
}
}
#ifndef QT_NO_OPENSSL
if (!QSslSocket::supportsSsl()) {
QMessageBox::information(0, "SpeechNav",
"This system does not support OpenSSL. SSL websites will not be available.");
}
#endif
QDesktopServices::setUrlHandler(QLatin1String("http"), this, "openUrl");
QString localSysName = QLocale::system().name();
installTranslator(QLatin1String("qt_") + localSysName);
#if defined(Q_WS_MAC)
connect(this, SIGNAL(lastWindowClosed()),
this, SLOT(lastWindowClosed()));
#endif
QTimer::singleShot(0, this, SLOT(postLaunch()));
// Set logger
QsLogging::Logger& logger = QsLogging::Logger::instance();
const QString sLogPath(QDir(applicationDirPath()).filePath("tsweb.log"));
logFileDestination = QsLogging::DestinationFactory::MakeFileDestination(sLogPath);
logger.addDestination(logFileDestination.get());
}
void QHelpSearchIndexWriter::run()
{
#if !defined(QT_NO_EXCEPTIONS)
try {
#endif
QMutexLocker mutexLocker(&mutex);
if (m_cancel)
return;
const bool reindex = this->m_reindex;
const QString collectionFile(this->m_collectionFile);
mutexLocker.unlock();
QHelpEngineCore engine(collectionFile, 0);
if (!engine.setupData())
return;
const QLatin1String key("CluceneIndexedNamespaces");
if (reindex)
engine.setCustomValue(key, QLatin1String(""));
QMap<QString, QDateTime> indexMap;
const QLatin1String oldKey("CluceneSearchNamespaces");
if (!engine.customValue(oldKey, QString()).isNull()) {
// old style qhc file < 4.4.2, need to convert...
const QStringList indexedNamespaces
= engine.customValue(oldKey).toString()
.split(QLatin1String("|"), QString::SkipEmptyParts);
foreach (const QString &nameSpace, indexedNamespaces)
indexMap.insert(nameSpace, QDateTime());
engine.removeCustomValue(oldKey);
} else {
QDataStream dataStream(engine.customValue(key).toByteArray());
dataStream >> indexMap;
}
QString indexPath = m_indexFilesFolder;
QFileInfo fInfo(indexPath);
if (fInfo.exists() && !fInfo.isWritable()) {
qWarning("Full Text Search, could not create index (missing permissions for '%s').",
qPrintable(indexPath));
return;
}
emit indexingStarted();
QCLuceneIndexWriter *writer = 0;
QCLuceneStandardAnalyzer analyzer;
const QStringList registeredDocs = engine.registeredDocumentations();
QLocalSocket localSocket;
localSocket.connectToServer(QString(QLatin1String("QtAssistant%1"))
.arg(QLatin1String(QT_VERSION_STR)));
QLocalServer localServer;
bool otherInstancesRunning = true;
if (!localSocket.waitForConnected()) {
otherInstancesRunning = false;
localServer.listen(QString(QLatin1String("QtAssistant%1"))
.arg(QLatin1String(QT_VERSION_STR)));
}
// check if it's locked, and if the other instance is running
if (!otherInstancesRunning && QCLuceneIndexReader::isLocked(indexPath))
QCLuceneIndexReader::unlock(indexPath);
if (QCLuceneIndexReader::isLocked(indexPath)) {
// poll unless indexing finished to fake progress
while (QCLuceneIndexReader::isLocked(indexPath)) {
mutexLocker.relock();
if (m_cancel)
break;
mutexLocker.unlock();
this->sleep(1);
}
emit indexingFinished();
return;
}
if (QCLuceneIndexReader::indexExists(indexPath) && !reindex) {
foreach(const QString &namespaceName, registeredDocs) {
mutexLocker.relock();
if (m_cancel) {
emit indexingFinished();
return;
}
mutexLocker.unlock();
if (!indexMap.contains(namespaceName)) {
// make sure we remove some partly indexed stuff
removeDocuments(indexPath, namespaceName);
} else {
QString path = engine.documentationFileName(namespaceName);
if (indexMap.value(namespaceName)
< QFileInfo(path).lastModified()) {
// make sure we remove some outdated indexed stuff
indexMap.remove(namespaceName);
removeDocuments(indexPath, namespaceName);
}
if (indexMap.contains(namespaceName)) {
// make sure we really have content indexed for namespace
QCLuceneTermQuery query(QCLuceneTerm(NamespaceField, namespaceName));
QCLuceneIndexSearcher indexSearcher(indexPath);
QCLuceneHits hits = indexSearcher.search(query);
if (hits.length() <= 0)
indexMap.remove(namespaceName);
}
}
}
void CLocalSvrCommunication::SocketError( QLocalSocket::LocalSocketError )
{
QLocalSocket* pSocket = qobject_cast< QLocalSocket* >( sender( ) );
emit NotifyMsg( pSocket->errorString( ) );
}
void CLocalSvrCommunication::HandleServerDisconnect( )
{
QLocalSocket* pSocket = qobject_cast< QLocalSocket* >( sender( ) );
pSocket->close( );
pSocket->deleteLater( );
}
void Application::newConnection()
{
QLocalSocket *socket = m_localServer->nextPendingConnection();
if (!socket)
{
return;
}
socket->waitForReadyRead(1000);
MainWindow *window = (getWindows().isEmpty() ? NULL : getWindow());
QString data;
QTextStream stream(socket);
stream >> data;
const QStringList encodedArguments = QString(QByteArray::fromBase64(data.toUtf8())).split(QLatin1Char(' '));
QStringList decodedArguments;
for (int i = 0; i < encodedArguments.count(); ++i)
{
decodedArguments.append(QString(QByteArray::fromBase64(encodedArguments.at(i).toUtf8())));
}
m_commandLineParser.parse(decodedArguments);
const QString session = m_commandLineParser.value(QLatin1String("session"));
const bool isPrivate = m_commandLineParser.isSet(QLatin1String("privatesession"));
if (session.isEmpty())
{
if (!window || !SettingsManager::getValue(QLatin1String("Browser/OpenLinksInNewTab")).toBool() || (isPrivate && !window->getWindowsManager()->isPrivate()))
{
window = createWindow(isPrivate);
}
}
else
{
const SessionInformation sessionData = SessionsManager::getSession(session);
if (sessionData.isClean || QMessageBox::warning(NULL, tr("Warning"), tr("This session was not saved correctly.\nAre you sure that you want to restore this session anyway?"), QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
for (int i = 0; i < sessionData.windows.count(); ++i)
{
createWindow(isPrivate, false, sessionData.windows.at(i));
}
}
}
if (window)
{
if (m_commandLineParser.positionalArguments().isEmpty())
{
window->triggerAction(ActionsManager::NewTabAction);
}
else
{
const QStringList urls = m_commandLineParser.positionalArguments();
for (int i = 0; i < urls.count(); ++i)
{
window->openUrl(urls.at(i));
}
}
}
delete socket;
if (window)
{
window->raise();
window->activateWindow();
if (m_isHidden)
{
setHidden(false);
}
else
{
window->storeWindowState();
window->restoreWindowState();
}
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
settings("Zeal", "Zeal"),
settingsDialog(zealList)
{
trayIcon = nullptr;
trayIconMenu = nullptr;
// Use the platform-specific proxy settings
QNetworkProxyFactory::setUseSystemConfiguration(true);
// server for detecting already running instances
localServer = new QLocalServer(this);
connect(localServer, &QLocalServer::newConnection, [&]() {
QLocalSocket *connection = localServer->nextPendingConnection();
// Wait a little while the other side writes the bytes
connection->waitForReadyRead();
QString indata = connection->readAll();
if(!indata.isEmpty()) {
bringToFrontAndSearch(indata);
}
});
QLocalServer::removeServer(serverName); // remove in case previous instance crashed
localServer->listen(serverName);
// initialise icons
#if defined(WIN32) || defined(OSX)
icon = qApp->style()->standardIcon(QStyle::SP_MessageBoxInformation);
#else
icon = QIcon::fromTheme("edit-find");
#endif
setWindowIcon(icon);
if(settings.value("hidingBehavior", "systray").toString() == "systray")
createTrayIcon();
QKeySequence keySequence;
if(settings.value("hotkey").isNull()) {
keySequence = QKeySequence("Alt+Space");
} else {
keySequence = settings.value("hotkey").value<QKeySequence>();
}
// initialise key grabber
connect(&nativeFilter, &ZealNativeEventFilter::gotHotKey, [&]() {
if(!isVisible() || !isActiveWindow()) {
bringToFront(true);
} else {
if(trayIcon) {
hide();
} else {
showMinimized();
}
}
});
qApp->eventDispatcher()->installNativeEventFilter(&nativeFilter);
setHotKey(keySequence);
// initialise docsets
docsets->initialiseDocsets();
// initialise ui
ui->setupUi(this);
setupShortcuts();
restoreGeometry(settings.value("geometry").toByteArray());
ui->splitter->restoreState(settings.value("splitter").toByteArray());
connect(ui->splitter, &QSplitter::splitterMoved, [=](int, int) {
settings.setValue("splitter", ui->splitter->saveState());
});
ui->webView->settings()->setFontSize(QWebSettings::MinimumFontSize, settings.value("minFontSize").toInt());
ZealNetworkAccessManager * zealNaManager = new ZealNetworkAccessManager();
ui->webView->page()->setNetworkAccessManager(zealNaManager);
// menu
ui->action_Quit->setShortcut(QKeySequence::Quit);
connect(ui->action_Quit, &QAction::triggered, [=]() { settings.setValue("geometry", saveGeometry()); });
connect(ui->action_Quit, SIGNAL(triggered()), qApp, SLOT(quit()));
connect(&settingsDialog, SIGNAL(refreshRequested()), this, SLOT(refreshRequest()));
connect(&settingsDialog, SIGNAL(minFontSizeChanged(int)), this, SLOT(changeMinFontSize(int)));
connect(ui->action_Options, &QAction::triggered, [=]() {
settingsDialog.setHotKey(hotKey);
nativeFilter.setEnabled(false);
if(settingsDialog.exec()) {
setHotKey(settingsDialog.hotKey());
if(settings.value("hidingBehavior").toString() == "systray") {
createTrayIcon();
} else if(trayIcon) {
trayIcon->deleteLater();
trayIconMenu->deleteLater();
trayIcon = nullptr;
trayIconMenu = nullptr;
}
} else {
// cancelled - restore previous value
ui->webView->settings()->setFontSize(QWebSettings::MinimumFontSize, settings.value("minFontSize").toInt());
}
nativeFilter.setEnabled(true);
ui->treeView->reset();
});
ui->action_Back->setShortcut(QKeySequence::Back);
ui->action_Forward->setShortcut(QKeySequence::Forward);
connect(ui->action_Back, &QAction::triggered, this, &MainWindow::back);
connect(ui->action_Forward, &QAction::triggered, this, &MainWindow::forward);
connect(ui->action_About, &QAction::triggered,
[&]() { QMessageBox::about(this, "About Zeal",
QString("This is Zeal ") + ZEAL_VERSION + " - a documentation browser.\n\n"
"For details see http://zealdocs.org/"); });
connect(ui->action_About_QT, &QAction::triggered,
[&]() { QMessageBox::aboutQt(this); });
displayViewActions();
// treeView and lineEdit
ui->lineEdit->setTreeView(ui->treeView);
ui->lineEdit->setFocus();
ui->treeView->setModel(&zealList);
ui->treeView->setColumnHidden(1, true);
ui->treeView->setItemDelegate(new ZealSearchItemDelegate(ui->treeView, ui->lineEdit, ui->treeView));
#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0) && defined(WIN32)
// overriding subElementRect doesn't work with Qt 5.0.0, but is required to display
// selected item frame correctly in Windows (for patch see https://codereview.qt-project.org/#change,46559)
// This is a workaround for Qt < 5.1 - selecting whole rows leads to always rendering the frame.
// (Only the frame is larger than the list item, which is different from default behaviour.)
ui->treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
#endif
connect(ui->treeView, &QTreeView::clicked, [&](const QModelIndex& index) {
ui->treeView->activated(index);
});
connect(ui->treeView, &QTreeView::activated, [&](const QModelIndex& index) {
if(!index.sibling(index.row(), 1).data().isNull()) {
QStringList url_l = index.sibling(index.row(), 1).data().toString().split('#');
QUrl url = QUrl::fromLocalFile(url_l[0]);
if(url_l.count() > 1) {
url.setFragment(url_l[1]);
}
ui->webView->load(url);
}
});
connect(ui->forwardButton, &QPushButton::clicked, this, &MainWindow::forward);
connect(ui->backButton, &QPushButton::clicked, this, &MainWindow::back);
connect(ui->webView, &SearchableWebView::urlChanged, [&](const QUrl &url) {
QString urlPath = url.path();
QString docsetName = getDocsetName(urlPath);
QPixmap docsetMap = docsets->icon(docsetName).pixmap(32,32);
// paint label with the icon
ui->pageIcon->setPixmap(docsetMap);
displayViewActions();
});
connect(ui->webView, &SearchableWebView::titleChanged, [&](const QString &title) {
if (!title.isEmpty()) {
ui->pageTitle->setText(title);
}
});
connect(&zealSearch, &ZealSearchModel::queryCompleted, [&]() {
ui->treeView->setModel(&zealSearch);
ui->treeView->reset();
ui->treeView->setColumnHidden(1, true);
ui->treeView->setCurrentIndex(zealSearch.index(0, 0, QModelIndex()));
ui->treeView->activated(ui->treeView->currentIndex());
});
connect(ui->lineEdit, &QLineEdit::textChanged, [&](const QString& text) {
zealSearch.setQuery(text);
if(text.isEmpty()) {
ui->treeView->setModel(&zealList);
}
});
}
