int main(int argc, char *argv[]) { QApplication app(argc, argv); // assure one application instance QString uniqueID( HomePrism_UUID ); QLocalSocket socket; socket.connectToServer(uniqueID); if (socket.waitForConnected(500)) { QMessageBox::critical(0, QObject::tr("HomePrism"), QObject::tr("Another HomePrism is already running. Will exit now.")); return EXIT_FAILURE; // Exit already a process running } // some app specific params QCoreApplication::setApplicationName( HomePrism_TITLE ); QCoreApplication::setOrganizationName("DKFZ"); // start HomePrism homePrismWindow; homePrismWindow.setGeometry( QStyle::alignedRect( Qt::LeftToRight, Qt::AlignCenter, homePrismWindow.size(), qApp->desktop()->availableGeometry() )); homePrismWindow.show(); //HomePrism.hide(); return app.exec(); }
bool Application::IsAlreadyRunning () const { QLocalSocket socket; socket.connectToServer (GetSocketName ()); if (socket.waitForConnected () || socket.state () == QLocalSocket::ConnectedState) { QDataStream out (&socket); out << Arguments_; if (socket.waitForBytesWritten ()) return true; if (socket.error() == QLocalSocket::UnknownSocketError) 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; }
bool ServerCatchcopy::listen() { QLocalSocket socketTestConnection; pathSocket=ExtraSocketCatchcopy::pathSocket(); socketTestConnection.connectToServer(QString::fromStdString(pathSocket)); if(socketTestConnection.waitForConnected(CATCHCOPY_COMMUNICATION_TIMEOUT)) { error_string="Other server is listening"; emit error(error_string); return false; } else { if(!server.removeServer(QString::fromStdString(pathSocket))) { error_string="Unable to remove the old server"; emit error(error_string); } #ifndef Q_OS_MAC server.setSocketOptions(QLocalServer::UserAccessOption); #endif if(server.listen(QString::fromStdString(pathSocket))) return true; else { error_string=QStringLiteral("Unable to listen %1: %2").arg(QString::fromStdString(pathSocket)).arg(server.errorString()).toStdString(); emit error(error_string); return false; } } }
// Process incoming IPC command. First check if monero-wallet-gui is // already running. If it is, send it to that instance instead, if not, // queue the command for later use inside our QML engine. Returns true // when queued, false if sent to another instance, at which point we can // kill the current process. bool IPC::saveCommand(QString cmdString){ qDebug() << QString("saveCommand called: %1").arg(cmdString); QLocalSocket ls; QByteArray buffer; buffer = buffer.append(cmdString); QString socketFilePath = this->socketFile().filePath(); ls.connectToServer(socketFilePath, QIODevice::WriteOnly); if(ls.waitForConnected(1000)){ ls.write(buffer); if (!ls.waitForBytesWritten(1000)){ qDebug() << QString("Could not send command \"%1\" over IPC %2: \"%3\"").arg(cmdString, socketFilePath, ls.errorString()); return false; } qDebug() << QString("Sent command \"%1\" over IPC \"%2\"").arg(cmdString, socketFilePath); return false; } if(ls.isOpen()) ls.disconnectFromServer(); // Queue for later this->SetQueuedCmd(cmdString); return true; }
void MainWidget::initLocalConnection() { is_running = false; QCoreApplication::setApplicationName("localserver"); QString serverName=QCoreApplication::applicationName(); QLocalSocket socket; socket.connectToServer(serverName); if(socket.waitForConnected(500)) { is_running =true; return; } //连接不上服务器,就创建一个 server = new QLocalServer(this); connect(server, SIGNAL(newConnection()), this, SLOT(newLocalConnection())); if(server->listen(serverName)) { //防止程序崩溃时,残留进程服务,移除之 if(server->serverError() == QAbstractSocket::AddressInUseError && QFile::exists(server->serverName())) { QFile::remove(server->serverName()); server->listen(serverName); } } }
// Helper function called by qt_connectToServer() void qt_connectToServer(const QString& server, bool retry = true) { bool connectToWidget = (server != qt_localServerName); // The QLocalSocket::waitForConnected does not respect the time out argument when the // gnuplot_qt application is not yet started. To wait for it, we need to implement the timeout ourselves QDateTime timeout = QDateTime::currentDateTime().addMSecs(1000); do { qt_socket.connectToServer(server); qt_socket.waitForConnected(200); // TODO: yield CPU ? } while((qt_socket.state() != QLocalSocket::ConnectedState) && (QDateTime::currentDateTime() < timeout)); // Still not connected... if ((qt_socket.state() != QLocalSocket::ConnectedState) && retry) { // The widget could not be reached: start a gnuplot_qt program which will create a QtGnuplotApplication if (connectToWidget) { qDebug() << "Could not connect to widget" << qt_optionWidget << ". Starting a QtGnuplotApplication"; qt_optionWidget = QString(); qt_connectToServer(qt_localServerName); } // The gnuplot_qt program could not be reached: try to start a new one else { qDebug() << "Could not connect gnuplot_qt" << qt_optionWidget << ". Starting a new one"; execGnuplotQt(); qt_connectToServer(qt_localServerName, false); } } }
QT_USE_NAMESPACE #define NO_DISCOVERED_CONFIGURATIONS_ERROR 1 #define SESSION_OPEN_ERROR 2 int main(int argc, char** argv) { QCoreApplication app(argc, argv); // Cannot read/write to processes on WinCE or Symbian. // Easiest alternative is to use sockets for IPC. QLocalSocket oopSocket; oopSocket.connectToServer("tst_qnetworksession"); oopSocket.waitForConnected(-1); QNetworkConfigurationManager manager; QList<QNetworkConfiguration> discovered = manager.allConfigurations(QNetworkConfiguration::Discovered); foreach(QNetworkConfiguration config, discovered) { qDebug() << "Lackey: Name of the config enumerated: " << config.name(); qDebug() << "Lackey: State of the config enumerated: " << config.state(); }
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; }
int main(int argc, char *argv[]) { QApplication a(argc, argv); //a.removeLibraryPath(a.libraryPaths().first()); qRegisterMetaType<Song>("Song"); qRegisterMetaTypeStreamOperators<Song>("Song"); MainWindow w; QStringList args = a.arguments(); QLocalSocket socket; socket.connectToServer("iniTunes"); QTextStream stream(&socket); if(socket.waitForConnected(3000)) { stream <<QString::number(PLAY)<<endl; stream << args.at(1) <<endl; socket.waitForBytesWritten(); exit(0); } else { qDebug()<<"Launch"; w.show(); w.createRemote(); if(args.count()==2) { qDebug()<<"Open"; w.open(args.at(1)); } } return a.exec(); }
int QmKeysPrivate::getKeyValue(const struct input_event &query) { // Try to connect to qmkeyd. QLocalSocket socket; socket.connectToServer(SERVER_NAME); if (!socket.waitForConnected(1000)) { return -1; } // Query for the given key if (socket.write((char*)&query, sizeof(query)) != sizeof(query)) { return -1; } if (!socket.waitForReadyRead(1000)) { return -1; } struct input_event response; int ret = 0; // A loop because we might receive other events as well. do { ret = socket.read((char*)&response, sizeof(response)); if (ret == sizeof(response)) { if (response.type == query.type && response.code == query.code) { break; } } } while (ret == sizeof(response)); socket.disconnect(); return response.value; }
void LocalClient::run() { QLocalSocket *socket = new QLocalSocket(this); socket->connectToServer("/tmp/testservice"); if (!socket->waitForConnected()) { qDebug() << "could not connect to server: " << socket->errorString(); return; } m_client = new QJsonRpcSocket(socket, this); QJsonRpcServiceReply *reply = m_client->invokeRemoteMethod("agent.testMethod"); connect(reply, SIGNAL(finished()), this, SLOT(processResponse())); reply = m_client->invokeRemoteMethod("agent.testMethodWithParams", "one", false, 10); connect(reply, SIGNAL(finished()), this, SLOT(processResponse())); reply = m_client->invokeRemoteMethod("agent.testMethodWithVariantParams", "one", false, 10, QVariant(2.5)); connect(reply, SIGNAL(finished()), this, SLOT(processResponse())); reply = m_client->invokeRemoteMethod("agent.testMethodWithParamsAndReturnValue", "matt"); connect(reply, SIGNAL(finished()), this, SLOT(processResponse())); // test bulk messages /* QJsonRpcMessage first = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessage"); m_client->sendMessage(first); QJsonRpcMessage second = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessages1"); QJsonRpcMessage third = QJsonRpcMessage::createRequest("agent.testMethodWithParamsAndReturnValue", "testSendMessages2"); m_client->sendMessage(QList<QJsonRpcMessage>() << second << third); */ }
void qt_connectToServer() { if (!qt_initialized) return; // Determine to which server we should connect QString server = qt_localServerName; if (!qt_optionWidget.isEmpty()) server = qt_optionWidget; // Check if we are already connected if (qt_socket.serverName() == server) return; // Disconnect if (qt_socket.state() == QLocalSocket::ConnectedState) { qt_socket.disconnectFromServer(); qt_socket.waitForDisconnected(1000); } // Connect to server, or local server if not available. qt_socket.connectToServer(server); if (!qt_socket.waitForConnected(3000)) while (qt_socket.state() != QLocalSocket::ConnectedState) qt_socket.connectToServer(qt_localServerName); }
bool N810GpsPlugin::sendToGpsDriverCtrl(QString cmd) { QLocalSocket *gpsCtrlSocket; gpsCtrlSocket = new QLocalSocket(this); QByteArray socketPath = ( "/var/lib/gps/gps_driver_ctrl"); gpsCtrlSocket->connectToServer(socketPath.data()); if(gpsCtrlSocket->waitForConnected()) { qLog(Hardware)<< __PRETTY_FUNCTION__ << "connected" << cmd; QByteArray data; data.append(cmd); data.append("\n"); gpsCtrlSocket->write(data); gpsCtrlSocket->flush(); gpsCtrlSocket->disconnectFromServer(); return true; } else { qLog(Hardware) << __PRETTY_FUNCTION__ << "Could not connect to socket" << gpsCtrlSocket; } return false; }
bool KNSingletonApplication::sendMessages(const QString &uniqueKey, const QStringList &messages) { //Create sender client. QLocalSocket client; //Link to the server which is listening to the unique key. client.connectToServer(uniqueKey, QIODevice::WriteOnly); //If connecting failed, return false. if(!client.waitForConnected(TimeoutLimit)) { qDebug("Cannot connect to the local server."); //Disconnect from the server. client.disconnectFromServer(); return false; } //Generate the message data. QByteArray messageData; QDataStream dataWriter(&messageData, QIODevice::WriteOnly); dataWriter << messages; //Send the data to local server. client.write(messageData); //Check sending status. if(!client.waitForBytesWritten(TimeoutLimit)) { qDebug("Send arguments failed."); client.disconnectFromServer(); return false; } //Send the arguments success. client.disconnectFromServer(); return true; }
int main(int argc, char *argv[]) { QApplication app(argc, argv); QLocalSocket localSocket; localSocket.connectToServer("bloggerQml", QIODevice::ReadOnly); if(localSocket.waitForConnected(5000)) { // there is already an application running qDebug() << "Application is already running."; QMessageBox::information(0, QObject::tr("Erro"), QObject::tr("A aplicação já está a ser executada."), QMessageBox::Ok); return 0; } QLocalServer localServer; localServer.listen("bloggerQml"); BloggerLoader bloggerloader; bloggerloader.loadBlogsFromFile(); BloggerProxyModel model; model.setSourceModel(bloggerloader.model()); Helper helper; QtQuick2ApplicationViewer viewer; viewer.rootContext()->setContextProperty("blogsModel", &model); viewer.rootContext()->setContextProperty("helper", &helper); viewer.rootContext()->setContextProperty("bloggerloader", &bloggerloader); viewer.setMainQmlFile(QStringLiteral("qml/blogerQML/main.qml")); viewer.showExpanded(); int res = app.exec(); bloggerloader.saveDB(); return res; }
QCopServerPrivate::QCopServerPrivate() : QCopLocalServer() { bool ok; #ifndef QT_NO_QCOP_LOCAL_SOCKET QString path = QCopThreadData::socketPath(); ok = listen(path); #ifdef Q_OS_UNIX if (!ok) { // There may be another qcop server running, or the path // was simply left in the filesystem after a server crash. // QLocalServer does not clean up such paths. We try to // connect to the existing qcop server, and if that fails // we remove the path and try again. QLocalSocket *socket = new QLocalSocket(); socket->connectToServer(path); if (!socket->waitForConnected()) { delete socket; QFile::remove(QDir::tempPath() + QChar('/') + path); ok = listen(path); } else { delete socket; } } #endif #else ok = listen(QHostAddress::LocalHost, QCopThreadData::listenPort()); QString path = QString::number(QCopThreadData::listenPort()); #endif if (!ok) qWarning() << "Could not listen for qcop connections on" << path << "; another qcop server may already be running."; }
bool SingleInstance::hasPrevious(const QString &name, const QStringList &args) { qDebug() << "Checking for previous instance..."; QLocalSocket socket; socket.connectToServer(name, QLocalSocket::ReadWrite); if (socket.waitForConnected()) { qDebug() << "Connection found!"; qDebug() << "Forwarding argument to existing instance..."; QByteArray buffer; for (auto item : args) { buffer.append(item+"\n"); } qDebug() << "Forwading buffer=" << buffer; socket.write(buffer); return true; } qDebug() << socket.errorString(); qDebug() << "No connection found"; return false; }
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); res &= socket.waitForReadyRead(timeout); // wait for ack res &= (socket.read(qstrlen(ack)) == ack); return res; }
// // Sending to the server is done synchronously, at startup. // If the server isn't already running, startup continues, // and the items in savedPaymentRequest will be handled // when uiReady() is called. // bool PaymentServer::ipcSendCommandLine() { bool fResult = false; for (const QString& r : savedPaymentRequests) { QLocalSocket* socket = new QLocalSocket(); socket->connectToServer(ipcServerName(), QIODevice::WriteOnly); if (!socket->waitForConnected(BITCOIN_IPC_CONNECT_TIMEOUT)) { delete socket; socket = nullptr; return false; } QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out.setVersion(QDataStream::Qt_4_0); out << r; out.device()->seek(0); socket->write(block); socket->flush(); socket->waitForBytesWritten(BITCOIN_IPC_CONNECT_TIMEOUT); socket->disconnectFromServer(); delete socket; socket = nullptr; fResult = true; } return fResult; }
bool MonavRunnerPrivate::retrieveData( const RouteRequest *route, const QString &mapDir, RoutingResult* reply ) const { QLocalSocket socket; socket.connectToServer( "MoNavD" ); if ( socket.waitForConnected() ) { if ( m_plugin->monavVersion() == MonavPlugin::Monav_0_3 ) { CommandType commandType; commandType.value = CommandType::RoutingCommand; commandType.post( &socket ); } RoutingCommand command; QVector<Node> waypoints; for ( int i = 0; i < route->size(); ++i ) { Node coordinate; coordinate.longitude = route->at( i ).longitude( GeoDataCoordinates::Degree ); coordinate.latitude = route->at( i ).latitude( GeoDataCoordinates::Degree ); waypoints << coordinate; } command.dataDirectory = mapDir; command.lookupRadius = 1500; command.waypoints = waypoints; command.lookupStrings = true; command.post( &socket ); socket.flush(); if ( reply->read( &socket ) ) { switch ( reply->type ) { case RoutingResult::LoadFailed: mDebug() << "failed to load monav map from " << mapDir; return false; break; case RoutingResult::RouteFailed: mDebug() << "failed to retrieve route from monav daemon"; return false; break; case RoutingResult::TypeLookupFailed: mDebug() << "failed to lookup type from monav daemon"; return false; break; case RoutingResult::NameLookupFailed: mDebug() << "failed to lookup name from monav daemon"; return false; break; case RoutingResult::Success: return true; } } else { mDebug() << "Failed to read reply"; } } else { mDebug() << "No connection to MoNavD"; } return false; }
bool YACReaderLocalServer::isRunning() { QLocalSocket socket; socket.connectToServer(YACREADERLIBRARY_GUID); if (socket.waitForConnected(500)) return true; // Server is running (another instance of YACReaderLibrary has been launched) return false; }
BrowserApplication::BrowserApplication(int &argc, char **argv, char *styleSheet,QSharedDataPointer<ProcessOptions> processOptions) : QApplication(argc, argv) , m_localServer(0) , m_privateProfile(0) , sawStyleSheetCommandLineOption(false) , nextSessionNameIndex(1) { nameTemplate = QLatin1String("domterm-%1"); QCoreApplication::setOrganizationName(QLatin1String("DomTerm")); QCoreApplication::setApplicationName(QLatin1String("QtDomTerm")); QCoreApplication::setApplicationVersion(QLatin1String(QTDOMTERM_VERSION)); QString serverName = QCoreApplication::applicationName() + QString::fromLatin1(QT_VERSION_STR).remove('.') + QLatin1String("webengine"); if (styleSheet != NULL) { m_stylesheetFilename = QString(styleSheet); sawStyleSheetCommandLineOption = true; } m_fileSystemWatcher = new QFileSystemWatcher(this); QLocalSocket socket; socket.connectToServer(serverName); if (socket.waitForConnected(500)) { QDataStream stream(&socket); stream << *processOptions; socket.waitForBytesWritten(); return; } #if defined(Q_OS_OSX) 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) && m_localServer->serverError() == QAbstractSocket::AddressInUseError) { QLocalServer::removeServer(serverName); if (!m_localServer->listen(serverName)) qWarning("Could not create local socket %s.", qPrintable(serverName)); } #ifndef QT_NO_OPENSSL if (!QSslSocket::supportsSsl()) { QMessageBox::information(0, "Demo Browser", "This system does not support OpenSSL. SSL websites will not be available."); } #endif QString localSysName = QLocale::system().name(); installTranslator(QLatin1String("qt_") + localSysName); QTimer::singleShot(0, this, SLOT(postLaunch())); }
int main(int argc, char **argv) { QCoreApplication app(argc, argv); QStringList args = app.arguments(); QString appName = args.takeFirst(); bool notification = args.contains("-n"); if (notification) args.removeAll("-n"); if (args.size() < 2) { qDebug("usage: %s [-n] <service> <method> <arguments>", appName.toLocal8Bit().data()); return -1; } // try to process socket QIODevice *device = 0; QScopedPointer<QIODevice> devicePtr(device); QString service = args.takeFirst(); QUrl serviceUrl = QUrl::fromUserInput(service); QHostAddress serviceAddress(serviceUrl.host()); if (serviceAddress.isNull()) { QLocalSocket *localSocket = new QLocalSocket; device = localSocket; localSocket->connectToServer(service); if (!localSocket->waitForConnected(5000)) { qDebug("could not connect to service: %s", service.toLocal8Bit().data()); return -1; } } else { QTcpSocket *tcpSocket = new QTcpSocket; device = tcpSocket; int servicePort = serviceUrl.port() ? serviceUrl.port() : 5555; tcpSocket->connectToHost(serviceAddress, servicePort); if (!tcpSocket->waitForConnected(5000)) { qDebug("could not connect to host at %s:%d", serviceUrl.host().toLocal8Bit().data(), servicePort); return -1; } } QJsonRpcSocket socket(device); QString method = args.takeFirst(); QVariantList arguments; foreach (QString arg, args) arguments.append(arg); QJsonRpcMessage request = notification ? QJsonRpcMessage::createNotification(method, arguments) : QJsonRpcMessage::createRequest(method, arguments); QJsonRpcMessage response = socket.sendMessageBlocking(request, 5000); if (response.type() == QJsonRpcMessage::Error) { qDebug("error(%d): %s", response.errorCode(), response.errorMessage().toLocal8Bit().data()); return -1; } qDebug() << response.result(); }
bool LH_QtPlugin_WebKit::sendQuit() { QLocalSocket sock; sock.connectToServer("LCDHost_WebKitServer"); if( !sock.waitForConnected(100) ) return false; WebKitCommand('Q').write(&sock); sock.waitForBytesWritten(100); sock.disconnectFromServer(); return true; }
bool socket_test_connect(QString server, int timeout) { QLocalSocket sock; sock.connectToServer(server); if (!sock.waitForConnected(timeout)) { return false; } sock.disconnectFromServer(); return true; }
void setupConnection() { QLocalSocket socket; socket.connectToServer(serverName); if (socket.waitForConnected(1000)) { this->running = true; } else { startServer(); } }
static bool isDeamonRunning() { #if USE_LOCAL_SOCKETS QLocalSocket socket; socket.connectToServer("gdrdeamon2"); #else QTcpSocket socket; socket.connectToHost("127.0.0.1", 15002); #endif return socket.waitForConnected(1000); }
QSingleApplication::QSingleApplication(int argc, char **argv):QApplication(argc,argv) { _isRunning=false; QCoreApplication::setApplicationName("localserver"); QString serverName=QCoreApplication::applicationName(); 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(); qDebug()<<"Connected server,program will quit"; socket.waitForBytesWritten(); /** *qApp->quit(); 此代码是用来退出事件循环的;在构造函数中,事件循环 *尚未启动,因此就无法退出. 最好就是设置标志判断在外部判断 */ _isRunning=true; return; } qDebug()<<"Can't connect to server,build a server"; server=new QLocalServer(this); connect(server,SIGNAL(newConnection()),this,SLOT(newLocalConnection())); if(server->listen(serverName)) { //防止程序崩溃时,残留进程服务,移除之 if(server->serverError()==QAbstractSocket::AddressInUseError&&QFile::exists(server->serverName())) { QFile::remove(server->serverName()); server->listen(serverName); } } }
bool DebugEngine::tryConnect() { QLocalSocket localSocket; localSocket.connectToServer(ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME),QIODevice::WriteOnly|QIODevice::Unbuffered); if(localSocket.waitForConnected(1000)) { localSocket.disconnectFromServer(); return true; } else return false; }
int main(int argc, char *argv[]) { //_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF ); //oldHandler = qInstallMsgHandler(msgHandler); QApplication a(argc, argv); QTranslator qtTranslator; qtTranslator.load(":/lang/qt_" + QLocale::system().name(), QLibraryInfo::location(QLibraryInfo::TranslationsPath)); a.installTranslator(&qtTranslator); QTranslator myappTranslator; myappTranslator.load(":/lang/xdcc_" + QLocale::system().name()); a.installTranslator(&myappTranslator); _singular = new QSharedMemory("DCClient"); if(_singular->attach(QSharedMemory::ReadWrite)) { _singular->detach(); if(argc >= 2) { QLocalSocket socket; socket.connectToServer("DCClientIPC"); if(socket.waitForConnected()) { QDataStream out(&socket); out << QString(argv[1]); socket.waitForBytesWritten(); } } return 0; } _singular->create(1); QApplication::setQuitOnLastWindowClosed(false); XDCC xdcc; int ret = a.exec(); delete _singular; return ret; }