Change project directory structure.

Change project directory structure according to application structure.
Change 'nox' configuration option to something more meaningful 'nogui'.
Rename 'Icons' folder to 'icons' (similar to other folders).
Partially add 'nowebui' option support.
Remove QConf project file.

src/app/app.pri

@@ -0,0 +1,40 @@
+INCLUDEPATH += $$PWD
+
+usesystemqtsingleapplication {
+    nogui {
+        CONFIG += qtsinglecoreapplication
+    } else {
+        CONFIG += qtsingleapplication
+    }
+} else {
+    nogui {
+        include(qtsingleapplication/qtsinglecoreapplication.pri)
+    } else {
+        include(qtsingleapplication/qtsingleapplication.pri)
+    }
+}
+
+!nogui {
+    macx {
+        HEADERS += $$PWD/qmacapplication.h
+        SOURCES += $$PWD/qmacapplication.cpp
+    }
+    HEADERS += $$PWD/sessionapplication.h
+    SOURCES += $$PWD/sessionapplication.cpp
+}
+
+HEADERS += $$PWD/application.h
+SOURCES += $$PWD/application.cpp
+
+nogui: HEADERS += $$PWD/headlessloader.h
+
+unix: HEADERS += $$PWD/stacktrace.h
+strace_win {
+    HEADERS += $$PWD/stacktrace_win.h
+    !nogui {
+        HEADERS += $$PWD/stacktrace_win_dlg.h
+        FORMS += $$PWD/stacktrace_win_dlg.ui
+    }
+}
+
+SOURCES += $$PWD/main.cpp

src/app/application.cpp

@@ -0,0 +1,105 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2014  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#include <QDebug>
+#include <QFileInfo>
+#include <QLocale>
+#include <QLibraryInfo>
+#include <QSysInfo>
+
+#if (!defined(DISABLE_GUI) && defined(Q_OS_MAC))
+#include <QFont>
+#endif
+
+#include "application.h"
+#include "preferences.h"
+
+Application::Application(const QString &id, int &argc, char **argv)
+#ifndef DISABLE_GUI
+    : SessionApplication(id, argc, argv)
+#else
+    : QtSingleCoreApplication(id, argc, argv)
+#endif
+{
+#if defined(Q_OS_MACX) && !defined(DISABLE_GUI)
+    if (QSysInfo::MacintoshVersion > QSysInfo::MV_10_8) {
+        // fix Mac OS X 10.9 (mavericks) font issue
+        // https://bugreports.qt-project.org/browse/QTBUG-32789
+        QFont::insertSubstitution(".Lucida Grande UI", "Lucida Grande");
+    }
+#endif
+    setApplicationName("qBittorrent");
+    initializeTranslation();
+#ifndef DISABLE_GUI
+    setStyleSheet("QStatusBar::item { border-width: 0; }");
+    setQuitOnLastWindowClosed(false);
+#endif
+}
+
+void Application::initializeTranslation()
+{
+    Preferences* const pref = Preferences::instance();
+    // Load translation
+    QString locale = pref->getLocale();
+    if (locale.isEmpty()) {
+        locale = QLocale::system().name();
+        pref->setLocale(locale);
+    }
+
+    if (qtTranslator_.load(
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+            QString::fromUtf8("qtbase_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath)) ||
+        qtTranslator_.load(
+#endif
+            QString::fromUtf8("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
+            qDebug("Qt %s locale recognized, using translation.", qPrintable(locale));
+    }
+    else {
+        qDebug("Qt %s locale unrecognized, using default (en).", qPrintable(locale));
+    }
+    installTranslator(&qtTranslator_);
+
+    if (translator_.load(QString::fromUtf8(":/lang/qbittorrent_") + locale)) {
+        qDebug("%s locale recognized, using translation.", qPrintable(locale));
+    }
+    else {
+        qDebug("%s locale unrecognized, using default (en).", qPrintable(locale));
+    }
+    installTranslator(&translator_);
+
+#ifndef DISABLE_GUI
+    if (locale.startsWith("ar") || locale.startsWith("he")) {
+        qDebug("Right to Left mode");
+        setLayoutDirection(Qt::RightToLeft);
+    }
+    else {
+        setLayoutDirection(Qt::LeftToRight);
+    }
+#endif
+}

src/app/application.h

@@ -0,0 +1,59 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2014  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#ifndef APPLICATION_H
+#define APPLICATION_H
+
+#include <QStringList>
+#include <QTranslator>
+
+#ifndef DISABLE_GUI
+#include "sessionapplication.h"
+#else
+#include "qtsinglecoreapplication.h"
+#endif
+
+class Application
+#ifndef DISABLE_GUI
+    : public SessionApplication
+#else
+    : public QtSingleCoreApplication
+#endif
+{
+public:
+    Application(const QString &id, int &argc, char **argv);
+
+private:
+    QTranslator qtTranslator_;
+    QTranslator translator_;
+
+    void initializeTranslation();
+};
+
+#endif // APPLICATION_H

src/app/headlessloader.h

@@ -0,0 +1,117 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2006  Christophe Dumez, Frédéric Lassabe
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#ifndef HEADLESSLOADER_H
+#define HEADLESSLOADER_H
+
+#include <QObject>
+#include <QCoreApplication>
+#include <QDebug>
+#include "preferences.h"
+#include "qbtsession.h"
+#include "fs_utils.h"
+#include "misc.h"
+#include "logger.h"
+#include "torrentpersistentdata.h"
+
+class HeadlessLoader: public QObject {
+  Q_OBJECT
+
+public:
+  HeadlessLoader(const QStringList &torrentCmdLine) {
+    connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(shutdownCleanUp()), Qt::DirectConnection);
+    Preferences* const pref = Preferences::instance();
+    // Enable Web UI
+    pref->setWebUiEnabled(true);
+    // Instanciate Bittorrent Object
+    connect(QBtSession::instance(), SIGNAL(newConsoleMessage(QString)), this, SLOT(displayConsoleMessage(QString)));
+    // Resume unfinished torrents
+    QBtSession::instance()->startUpTorrents();
+    // Process command line parameters
+    processParams(torrentCmdLine);
+    // Display some information to the user
+    std::cout << std::endl << "******** " << qPrintable(tr("Information")) << " ********" << std::endl;
+    std::cout << qPrintable(tr("To control qBittorrent, access the Web UI at http://localhost:%1").arg(QString::number(pref->getWebUiPort()))) << std::endl;
+    std::cout << qPrintable(tr("The Web UI administrator user name is: %1").arg(pref->getWebUiUsername())) << std::endl;
+    qDebug() << "Password:" << pref->getWebUiPassword();
+    if (pref->getWebUiPassword() == "f6fdffe48c908deb0f4c3bd36c032e72") {
+      std::cout << qPrintable(tr("The Web UI administrator password is still the default one: %1").arg("adminadmin")) << std::endl;
+      std::cout << qPrintable(tr("This is a security risk, please consider changing your password from program preferences.")) << std::endl;
+    }
+  }
+
+public slots:
+  void shutdownCleanUp() {
+    QBtSession::drop();
+    TorrentPersistentData::drop();
+    Preferences::drop();
+    Logger::drop();
+  }
+
+  // Call this function to exit qBittorrent headless loader
+  // and return to prompt (object will be deleted by main)
+  void exit() {
+    qApp->quit();
+  }
+
+  void displayConsoleMessage(const QString &msg) {
+    std::cout << qPrintable(msg) << std::endl;
+  }
+
+  void processParams(const QString& params_str) {
+    processParams(params_str.split(" ", QString::SkipEmptyParts));
+  }
+
+  // As program parameters, we can get paths or urls.
+  // This function parse the parameters and call
+  // the right addTorrent function, considering
+  // the parameter type.
+  void processParams(const QStringList& params) {
+    foreach (QString param, params) {
+      param = fsutils::fromNativePath(param).trimmed();
+      if (param.startsWith(QString::fromUtf8("http://"), Qt::CaseInsensitive) || param.startsWith(QString::fromUtf8("ftp://"), Qt::CaseInsensitive) || param.startsWith(QString::fromUtf8("https://"), Qt::CaseInsensitive)) {
+        QBtSession::instance()->downloadFromUrl(param);
+      }else{
+        if (param.startsWith("bc://bt/", Qt::CaseInsensitive)) {
+          qDebug("Converting bc link to magnet link");
+          param = misc::bcLinkToMagnet(param);
+        }
+        if (param.startsWith("magnet:", Qt::CaseInsensitive)) {
+          QBtSession::instance()->addMagnetUri(param);
+        } else {
+          QBtSession::instance()->addTorrent(param);
+        }
+      }
+    }
+  }
+
+};
+
+#endif

src/app/main.cpp

@@ -0,0 +1,521 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2014  Vladimir Golovnev <glassez@yandex.ru>
+ * Copyright (C) 2006  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include <QDebug>
+#include <QScopedPointer>
+
+#ifndef DISABLE_GUI
+#include <QFont>
+#include <QMessageBox>
+#include <QPainter>
+#include <QPen>
+#include <QPushButton>
+#include <QSplashScreen>
+#include <QStyle>
+#include <QStyleFactory>
+#ifdef QBT_STATIC_QT
+#include <QtPlugin>
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+Q_IMPORT_PLUGIN(QICOPlugin)
+#else
+Q_IMPORT_PLUGIN(qico)
+#endif
+#endif // QBT_STATIC_QT
+#include "mainwindow.h"
+#include "ico.h"
+#else // DISABLE_GUI
+#include <iostream>
+#include <stdio.h>
+#include "headlessloader.h"
+#endif // DISABLE_GUI
+
+#include "application.h"
+
+#ifdef Q_OS_UNIX
+#include <signal.h>
+#include <execinfo.h>
+#include "stacktrace.h"
+#endif // Q_OS_UNIX
+
+#ifdef STACKTRACE_WIN
+#include <signal.h>
+#include "stacktrace_win.h"
+#include "stacktrace_win_dlg.h"
+#endif //STACKTRACE_WIN
+
+#include <stdlib.h>
+#include "misc.h"
+#include "preferences.h"
+#include "logger.h"
+
+class MessagesCollector : public QObject
+{
+    Q_OBJECT
+public slots:
+    void collectMessage(const QString& message)
+    {
+        messages.append(message.split("|", QString::SkipEmptyParts));
+    }
+public:
+    QStringList messages;
+};
+
+#include "main.moc"
+
+#if defined(Q_OS_WIN) && !defined(QBT_HAS_GETCURRENTPID)
+#error You seem to have updated QtSingleApplication without porting our custom QtSingleApplication::getRunningPid() function. Please see previous version to understate how it works.
+#endif
+
+// Signal handlers
+#if defined(Q_OS_UNIX) || defined(STACKTRACE_WIN)
+void sigintHandler(int);
+void sigtermHandler(int);
+void sigsegvHandler(int);
+void sigabrtHandler(int);
+#endif
+
+struct QBtCommandLineParameters
+{
+    bool showHelp;
+#ifndef Q_OS_WIN
+    bool showVersion;
+#endif
+#ifndef DISABLE_GUI
+    bool noSplash;
+#else
+    bool shouldDaemonize;
+#endif
+    int webUiPort;
+    QStringList torrents;
+    QString unknownParameter;
+
+    QBtCommandLineParameters()
+        : showHelp(false)
+#ifndef Q_OS_WIN
+        , showVersion(false)
+#endif
+#ifndef DISABLE_GUI
+        , noSplash(Preferences::instance()->isSplashScreenDisabled())
+#else
+        , shouldDaemonize(false)
+#endif
+        , webUiPort(Preferences::instance()->getWebUiPort())
+    {
+    }
+};
+
+#ifndef DISABLE_GUI
+void showSplashScreen();
+#endif
+void displayVersion();
+void displayUsage(const QString &prg_name);
+bool userAgreesWithLegalNotice();
+void displayBadArgMessage(const QString &message);
+QBtCommandLineParameters parseCommandLine();
+
+// Main
+int main(int argc, char *argv[])
+{
+    //Initialize logger singleton here to avoid threading issues
+    Logger::instance()->addMessage(QObject::tr("qBittorrent %1 started", "qBittorrent v3.2.0alpha started").arg(VERSION));
+    // We must save it here because QApplication constructor may change it
+    bool isOneArg = (argc == 2);
+
+    // Create Application
+    QScopedPointer<Application> app(new Application("qBittorrent-" + misc::getUserIDString(), argc, argv));
+
+    MessagesCollector* messagesCollector = new MessagesCollector();
+    QObject::connect(app.data(), SIGNAL(messageReceived(const QString &)),
+                     messagesCollector, SLOT(collectMessage(const QString &)));
+
+    const QBtCommandLineParameters params = parseCommandLine();
+
+    if (!params.unknownParameter.isEmpty()) {
+        displayBadArgMessage(QObject::tr("%1 is an unknown command line parameter.", "--random-parameter is an unknown command line parameter.")
+                             .arg(params.unknownParameter));
+        return EXIT_FAILURE;
+    }
+
+#ifndef Q_OS_WIN
+    if (params.showVersion) {
+        if (isOneArg) {
+            displayVersion();
+            return EXIT_SUCCESS;
+        }
+        else {
+            displayBadArgMessage(QObject::tr("%1 must be the single command line parameter.")
+                                 .arg(QLatin1String("-v (or --version)")));
+            return EXIT_FAILURE;
+        }
+    }
+#endif
+
+    if (params.showHelp) {
+        if (isOneArg) {
+            displayUsage(argv[0]);
+            return EXIT_SUCCESS;
+        }
+        else {
+            displayBadArgMessage(QObject::tr("%1 must be the single command line parameter.")
+                                 .arg(QLatin1String("-h (or --help)")));
+            return EXIT_FAILURE;
+        }
+    }
+
+    if ((params.webUiPort > 0) && (params.webUiPort <= 65535)) {
+        Preferences::instance()->setWebUiPort(params.webUiPort);
+    }
+    else {
+        displayBadArgMessage(QObject::tr("%1 must specify the correct port (1 to 65535).")
+                             .arg(QLatin1String("--webui-port")));
+        return EXIT_FAILURE;
+    }
+
+    // Set environment variable
+    if (!qputenv("QBITTORRENT", QByteArray(VERSION)))
+        std::cerr << "Couldn't set environment variable...\n";
+
+    if (!userAgreesWithLegalNotice())
+        return EXIT_SUCCESS;
+
+    // Check if qBittorrent is already running for this user
+    if (app->isRunning()) {
+#ifdef DISABLE_GUI
+        if (params.shouldDaemonize) {
+            displayBadArgMessage(QObject::tr("You cannot use %1: qBittorrent is already running for this user.")
+                                 .arg(QLatin1String("-d (or --daemon)")));
+            return EXIT_FAILURE;
+        }
+#else
+        qDebug("qBittorrent is already running for this user.");
+#endif
+        misc::msleep(300);
+#ifdef Q_OS_WIN
+        DWORD pid = (DWORD)app->getRunningPid();
+        if (pid > 0) {
+            BOOL b = AllowSetForegroundWindow(pid);
+            qDebug("AllowSetForegroundWindow() returns %s", b ? "TRUE" : "FALSE");
+        }
+#endif
+        if (!params.torrents.isEmpty()) {
+            QString message = params.torrents.join("|");
+            qDebug("Passing program parameters to running instance...");
+            qDebug("Message: %s", qPrintable(message));
+            app->sendMessage(message);
+        }
+        else { // Raise main window
+            app->sendMessage("qbt://show");
+        }
+
+        return EXIT_SUCCESS;
+    }
+
+    srand(time(0));
+#ifdef DISABLE_GUI
+    if (params.shouldDaemonize) {
+        app.reset(); // Destroy current application
+        if ((daemon(1, 0) == 0)) {
+            app.reset(new Application("qBittorrent-" + misc::getUserIDString(), argc, argv));
+            if (app->isRunning()) {
+                // Another instance had time to start.
+                return EXIT_FAILURE;
+            }
+        }
+        else {
+            qCritical("Something went wrong while daemonizing, exiting...");
+            return EXIT_FAILURE;
+        }
+    }
+#else
+    if (!params.noSplash)
+        showSplashScreen();
+#endif
+
+#if defined(Q_OS_UNIX) || defined(STACKTRACE_WIN)
+    signal(SIGABRT, sigabrtHandler);
+    signal(SIGTERM, sigtermHandler);
+    signal(SIGINT, sigintHandler);
+    signal(SIGSEGV, sigsegvHandler);
+#endif
+
+#ifndef DISABLE_GUI
+    MainWindow window(0, params.torrents);
+    QObject::connect(app.data(), SIGNAL(messageReceived(const QString &)),
+                     &window, SLOT(processParams(const QString &)));
+    QObject::disconnect(app.data(), SIGNAL(messageReceived(const QString &)),
+                        messagesCollector, SLOT(collectMessage(const QString &)));
+    window.processParams(messagesCollector->messages);
+    delete messagesCollector;
+    app->setActivationWindow(&window);
+#ifdef Q_OS_MAC
+    static_cast<QMacApplication*>(app.data())->setReadyToProcessEvents();
+#endif // Q_OS_MAC
+#else
+    // Load Headless class
+    HeadlessLoader loader(params.torrents);
+    QObject::connect(app.data(), SIGNAL(messageReceived(const QString &)),
+                     &loader, SLOT(processParams(const QString &)));
+    QObject::disconnect(app.data(), SIGNAL(messageReceived(const QString &)),
+                        messagesCollector, SLOT(collectMessage(const QString &)));
+    loader.processParams(messagesCollector->messages);
+    delete messagesCollector;
+#endif
+
+    int ret = app->exec();
+    qDebug("Application has exited");
+    return ret;
+}
+
+QBtCommandLineParameters parseCommandLine()
+{
+    QBtCommandLineParameters result;
+    QStringList appArguments = qApp->arguments();
+
+    for (int i = 1; i < appArguments.size(); ++i) {
+        const QString& arg = appArguments[i];
+
+        if ((arg.startsWith("--") && !arg.endsWith(".torrent")) ||
+            (arg.startsWith("-") && arg.size() == 2)) {
+            //Parse known parameters
+            if ((arg == QLatin1String("-h")) || (arg == QLatin1String("--help"))) {
+                result.showHelp = true;
+            }
+#ifndef Q_OS_WIN
+            else if ((arg == QLatin1String("-v")) || (arg == QLatin1String("--version"))) {
+                result.showVersion = true;
+            }
+#endif
+            else if (arg.startsWith(QLatin1String("--webui-port="))) {
+                QStringList parts = arg.split(QLatin1Char('='));
+                if (parts.size() == 2)
+                    result.webUiPort = parts.last().toInt();
+            }
+#ifndef DISABLE_GUI
+            else if (arg == QLatin1String("--no-splash")) {
+                result.noSplash = true;
+            }
+#else
+            else if ((arg == QLatin1String("-d")) || (arg == QLatin1String("--daemon"))) {
+                result.shouldDaemonize = true;
+            }
+#endif
+            else {
+                //Unknown argument
+                result.unknownParameter = arg;
+                break;
+            }
+        }
+        else {
+            QFileInfo torrentPath;
+            torrentPath.setFile(arg);
+
+            if (torrentPath.exists())
+                result.torrents += torrentPath.absoluteFilePath();
+            else
+                result.torrents += arg;
+        }
+    }
+
+    return result;
+}
+
+#if defined(Q_OS_UNIX) || defined(STACKTRACE_WIN)
+void sigintHandler(int)
+{
+    signal(SIGINT, 0);
+    qDebug("Catching SIGINT, exiting cleanly");
+    qApp->exit();
+}
+
+void sigtermHandler(int)
+{
+    signal(SIGTERM, 0);
+    qDebug("Catching SIGTERM, exiting cleanly");
+    qApp->exit();
+}
+
+void sigsegvHandler(int)
+{
+    signal(SIGABRT, 0);
+    signal(SIGSEGV, 0);
+#if !defined Q_OS_WIN && !defined Q_OS_HAIKU
+    std::cerr << "\n\n*************************************************************\n";
+    std::cerr << "Catching SIGSEGV, please report a bug at http://bug.qbittorrent.org\nand provide the following backtrace:\n";
+    std::cerr << "qBittorrent version: " << VERSION << std::endl;
+    print_stacktrace();
+#else
+#ifdef STACKTRACE_WIN
+    StraceDlg dlg;
+    dlg.setStacktraceString(straceWin::getBacktrace());
+    dlg.exec();
+#endif
+#endif
+    raise(SIGSEGV);
+}
+
+void sigabrtHandler(int)
+{
+    signal(SIGABRT, 0);
+    signal(SIGSEGV, 0);
+#if !defined Q_OS_WIN && !defined Q_OS_HAIKU
+    std::cerr << "\n\n*************************************************************\n";
+    std::cerr << "Catching SIGABRT, please report a bug at http://bug.qbittorrent.org\nand provide the following backtrace:\n";
+    std::cerr << "qBittorrent version: " << VERSION << std::endl;
+    print_stacktrace();
+#else
+#ifdef STACKTRACE_WIN
+    StraceDlg dlg;
+    dlg.setStacktraceString(straceWin::getBacktrace());
+    dlg.exec();
+#endif
+#endif
+    raise(SIGABRT);
+}
+#endif
+
+#ifndef DISABLE_GUI
+void showSplashScreen()
+{
+    QPixmap splash_img(":/icons/skin/splash.png");
+    QPainter painter(&splash_img);
+    QString version = VERSION;
+    painter.setPen(QPen(Qt::white));
+    painter.setFont(QFont("Arial", 22, QFont::Black));
+    painter.drawText(224 - painter.fontMetrics().width(version), 270, version);
+    QSplashScreen *splash = new QSplashScreen(splash_img, Qt::WindowStaysOnTopHint);
+    QTimer::singleShot(1500, splash, SLOT(deleteLater()));
+    splash->show();
+    qApp->processEvents();
+}
+#endif
+
+void displayVersion()
+{
+    std::cout << qPrintable(qApp->applicationName()) << " " << VERSION << std::endl;
+}
+
+QString makeUsage(const QString &prg_name)
+{
+    QString text;
+
+    text += QObject::tr("Usage:") + QLatin1Char('\n');
+#ifndef Q_OS_WIN
+    text += QLatin1Char('\t') + prg_name + QLatin1String(" (-v | --version)") + QLatin1Char('\n');
+#endif
+    text += QLatin1Char('\t') + prg_name + QLatin1String(" (-h | --help)") + QLatin1Char('\n');
+    text += QLatin1Char('\t') + prg_name
+            + QLatin1String(" [--webui-port=<port>]")
+#ifndef DISABLE_GUI
+            + QLatin1String(" [--no-splash]")
+#else
+            + QLatin1String(" [-d | --daemon]")
+#endif
+            + QLatin1String("[(<filename> | <url>)...]") + QLatin1Char('\n');
+    text += QObject::tr("Options:") + QLatin1Char('\n');
+#ifndef Q_OS_WIN
+    text += QLatin1String("\t-v | --version\t\t") + QObject::tr("Displays program version") + QLatin1Char('\n');
+#endif
+    text += QLatin1String("\t-h | --help\t\t") + QObject::tr("Displays this help message") + QLatin1Char('\n');
+    text += QLatin1String("\t--webui-port=<port>\t")
+            + QObject::tr("Changes the webui port (current: %1)").arg(QString::number(Preferences::instance()->getWebUiPort()))
+            + QLatin1Char('\n');
+#ifndef DISABLE_GUI
+    text += QLatin1String("\t--no-splash\t\t") + QObject::tr("Disable splash screen") + QLatin1Char('\n');
+#else
+    text += QLatin1String("\t-d | --daemon\t\t") + QObject::tr("Run in daemon-mode (background)") + QLatin1Char('\n');
+#endif
+    text += QLatin1String("\tfiles or urls\t\t") + QObject::tr("Downloads the torrents passed by the user");
+
+    return text;
+}
+
+void displayUsage(const QString& prg_name)
+{
+#ifndef Q_OS_WIN
+    std::cout << qPrintable(makeUsage(prg_name)) << std::endl;
+#else
+    QMessageBox msgBox(QMessageBox::Information, QObject::tr("Help"), makeUsage(prg_name), QMessageBox::Ok);
+    msgBox.show(); // Need to be shown or to moveToCenter does not work
+    msgBox.move(misc::screenCenter(&msgBox));
+    msgBox.exec();
+#endif
+}
+
+void displayBadArgMessage(const QString& message)
+{
+    QString help = QObject::tr("Run application with -h option to read about command line parameters.");
+#ifdef Q_OS_WIN
+    QMessageBox msgBox(QMessageBox::Critical, QObject::tr("Bad command line"),
+                       message + QLatin1Char('\n') + help, QMessageBox::Ok);
+    msgBox.show(); // Need to be shown or to moveToCenter does not work
+    msgBox.move(misc::screenCenter(&msgBox));
+    msgBox.exec();
+#else
+    std::cerr << qPrintable(QObject::tr("Bad command line: "));
+    std::cerr << qPrintable(message) << std::endl;
+    std::cerr << qPrintable(help) << std::endl;
+#endif
+}
+
+bool userAgreesWithLegalNotice()
+{
+    Preferences* const pref = Preferences::instance();
+    if (pref->getAcceptedLegal()) // Already accepted once
+        return true;
+
+#ifdef DISABLE_GUI
+    std::cout << std::endl << "*** " << qPrintable(QObject::tr("Legal Notice")) << " ***" << std::endl;
+    std::cout << qPrintable(QObject::tr("qBittorrent is a file sharing program. When you run a torrent, its data will be made available to others by means of upload. Any content you share is your sole responsibility.\n\nNo further notices will be issued.")) << std::endl << std::endl;
+    std::cout << qPrintable(QObject::tr("Press %1 key to accept and continue...").arg("'y'")) << std::endl;
+    char ret = getchar(); // Read pressed key
+    if (ret == 'y' || ret == 'Y') {
+        // Save the answer
+        pref->setAcceptedLegal(true);
+        return true;
+    }
+#else
+    QMessageBox msgBox;
+    msgBox.setText(QObject::tr("qBittorrent is a file sharing program. When you run a torrent, its data will be made available to others by means of upload. Any content you share is your sole responsibility.\n\nNo further notices will be issued."));
+    msgBox.setWindowTitle(QObject::tr("Legal notice"));
+    msgBox.addButton(QObject::tr("Cancel"), QMessageBox::RejectRole);
+    QAbstractButton *agree_button = msgBox.addButton(QObject::tr("I Agree"), QMessageBox::AcceptRole);
+    msgBox.show(); // Need to be shown or to moveToCenter does not work
+    msgBox.move(misc::screenCenter(&msgBox));
+    msgBox.exec();
+    if (msgBox.clickedButton() == agree_button) {
+        // Save the answer
+        pref->setAcceptedLegal(true);
+        return true;
+    }
+#endif
+
+    return false;
+}

src/app/qmacapplication.cpp

@@ -0,0 +1,72 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2010  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include <QEvent>
+#include <QFileOpenEvent>
+#include <QUrl>
+#include "qmacapplication.h"
+
+QMacApplication::QMacApplication(QString appid, int &argc, char** argv) :
+  QtSingleApplication(appid, argc, argv),
+  m_readyToProcessEvents(false)
+{
+  qDebug("Constructing a QMacApplication to receive file open events");
+}
+
+void QMacApplication::setReadyToProcessEvents()
+{
+  m_readyToProcessEvents = true;
+  if (!m_torrentsQueue.isEmpty()) {
+    emit newFileOpenMacEvent(m_torrentsQueue.join("|"));
+    m_torrentsQueue.clear();
+  }
+}
+
+bool QMacApplication::event(QEvent * ev) {
+  switch (ev->type()) {
+  case QEvent::FileOpen:
+    {
+      QString path = static_cast<QFileOpenEvent *>(ev)->file();
+      if (path.isEmpty()) {
+        // Get the url instead
+        path = static_cast<QFileOpenEvent *>(ev)->url().toString();
+      }
+      qDebug("Received a mac file open event: %s", qPrintable(path));
+      if (m_readyToProcessEvents)
+        emit newFileOpenMacEvent(path);
+      else
+        m_torrentsQueue.append(path);
+      return true;
+    }
+  default:
+    return QtSingleApplication::event(ev);
+  }
+}
+

src/app/qmacapplication.h

@@ -0,0 +1,54 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2010  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+#ifndef QMACAPPLICATION_H
+#define QMACAPPLICATION_H
+
+#include "qtsingleapplication.h"
+#include <QStringList>
+
+class QMacApplication : public QtSingleApplication
+{
+  Q_OBJECT
+public:
+  explicit QMacApplication(QString appid, int &argc, char** argv);
+  void setReadyToProcessEvents();
+
+signals:
+  void newFileOpenMacEvent(const QString &path);
+
+protected:
+  bool event(QEvent *);
+
+private:
+  bool m_readyToProcessEvents;
+  QStringList m_torrentsQueue;
+};
+
+#endif // QMACAPPLICATION_H

src/app/qtsingleapplication/QtLockedFile

@@ -0,0 +1 @@
+#include "qtlockedfile.h"

src/app/qtsingleapplication/QtSingleApplication

@@ -0,0 +1 @@
+#include "qtsingleapplication.h"

src/app/qtsingleapplication/qtlocalpeer.cpp

@@ -0,0 +1,250 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtlocalpeer.h"
+#include <QCoreApplication>
+#include <QTime>
+
+#if defined(Q_OS_WIN)
+#include <QLibrary>
+#include <qt_windows.h>
+typedef BOOL(WINAPI*PProcessIdToSessionId)(DWORD,DWORD*);
+static PProcessIdToSessionId pProcessIdToSessionId = 0;
+#endif
+#if defined(Q_OS_UNIX)
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#endif
+
+namespace QtLP_Private {
+#include "qtlockedfile.cpp"
+#if defined(Q_OS_WIN)
+#include "qtlockedfile_win.cpp"
+#else
+#include "qtlockedfile_unix.cpp"
+#endif
+}
+
+const char* QtLocalPeer::ack = "ack";
+
+QtLocalPeer::QtLocalPeer(QObject* parent, const QString &appId)
+    : QObject(parent), id(appId)
+{
+    QString prefix = id;
+    if (id.isEmpty()) {
+        id = QCoreApplication::applicationFilePath();
+#if defined(Q_OS_WIN)
+        id = id.toLower();
+#endif
+        prefix = id.section(QLatin1Char('/'), -1);
+    }
+    prefix.remove(QRegExp("[^a-zA-Z]"));
+    prefix.truncate(6);
+
+    QByteArray idc = id.toUtf8();
+    quint16 idNum = qChecksum(idc.constData(), idc.size());
+    socketName = QLatin1String("qtsingleapp-") + prefix
+                 + QLatin1Char('-') + QString::number(idNum, 16);
+
+#if defined(Q_OS_WIN)
+    if (!pProcessIdToSessionId) {
+        QLibrary lib("kernel32");
+        pProcessIdToSessionId = (PProcessIdToSessionId)lib.resolve("ProcessIdToSessionId");
+    }
+    if (pProcessIdToSessionId) {
+        DWORD sessionId = 0;
+        pProcessIdToSessionId(GetCurrentProcessId(), &sessionId);
+        socketName += QLatin1Char('-') + QString::number(sessionId, 16);
+    }
+#else
+    socketName += QLatin1Char('-') + QString::number(::getuid(), 16);
+#endif
+
+    server = new QLocalServer(this);
+    QString lockName = QDir(QDir::tempPath()).absolutePath()
+                       + QLatin1Char('/') + socketName
+                       + QLatin1String("-lockfile");
+    lockFile.setFileName(lockName);
+    lockFile.open(QIODevice::ReadWrite);
+}
+
+
+
+bool QtLocalPeer::isClient()
+{
+    if (lockFile.isLocked())
+        return false;
+
+    if (!lockFile.lock(QtLP_Private::QtLockedFile::WriteLock, false))
+        return true;
+
+    bool res = server->listen(socketName);
+#if defined(Q_OS_UNIX) && (QT_VERSION >= QT_VERSION_CHECK(4,5,0))
+    // ### Workaround
+    if (!res && server->serverError() == QAbstractSocket::AddressInUseError) {
+        QFile::remove(QDir::cleanPath(QDir::tempPath())+QLatin1Char('/')+socketName);
+        res = server->listen(socketName);
+    }
+#endif
+    if (!res)
+        qWarning("QtSingleCoreApplication: listen on local socket failed, %s", qPrintable(server->errorString()));
+    QObject::connect(server, SIGNAL(newConnection()), SLOT(receiveConnection()));
+    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);
+    if (res) {
+        res &= socket.waitForReadyRead(timeout);   // wait for ack
+        if (res)
+            res &= (socket.read(qstrlen(ack)) == ack);
+    }
+    return res;
+}
+
+
+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));
+#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);
+    socket->waitForDisconnected(1000); // make sure client reads ack
+    delete socket;
+#ifdef Q_OS_WIN
+    if (message == "qbt://pid")
+      return;
+#endif
+    emit messageReceived(message); //### (might take a long time to return)
+}
+
+#ifdef Q_OS_WIN
+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;
+}
+#endif

src/app/qtsingleapplication/qtlocalpeer.h

@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTLOCALPEER_H
+#define QTLOCALPEER_H
+
+#include <QLocalServer>
+#include <QLocalSocket>
+#include <QDir>
+
+#include "qtlockedfile.h"
+
+class QtLocalPeer : public QObject
+{
+    Q_OBJECT
+
+public:
+    QtLocalPeer(QObject *parent = 0, const QString &appId = QString());
+    bool isClient();
+    bool sendMessage(const QString &message, int timeout);
+    QString applicationId() const
+        { return id; }
+#ifdef Q_OS_WIN
+    qint64 getRunningPid();
+#endif
+
+Q_SIGNALS:
+    void messageReceived(const QString &message);
+
+protected Q_SLOTS:
+    void receiveConnection();
+
+protected:
+    QString id;
+    QString socketName;
+    QLocalServer* server;
+    QtLP_Private::QtLockedFile lockFile;
+
+private:
+    static const char* ack;
+};
+
+#endif // QTLOCALPEER_H

src/app/qtsingleapplication/qtlockedfile.cpp

@@ -0,0 +1,193 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtlockedfile.h"
+
+/*!
+    \class QtLockedFile
+
+    \brief The QtLockedFile class extends QFile with advisory locking
+    functions.
+
+    A file may be locked in read or write mode. Multiple instances of
+    \e QtLockedFile, created in multiple processes running on the same
+    machine, may have a file locked in read mode. Exactly one instance
+    may have it locked in write mode. A read and a write lock cannot
+    exist simultaneously on the same file.
+
+    The file locks are advisory. This means that nothing prevents
+    another process from manipulating a locked file using QFile or
+    file system functions offered by the OS. Serialization is only
+    guaranteed if all processes that access the file use
+    QLockedFile. Also, while holding a lock on a file, a process
+    must not open the same file again (through any API), or locks
+    can be unexpectedly lost.
+
+    The lock provided by an instance of \e QtLockedFile is released
+    whenever the program terminates. This is true even when the
+    program crashes and no destructors are called.
+*/
+
+/*! \enum QtLockedFile::LockMode
+
+    This enum describes the available lock modes.
+
+    \value ReadLock A read lock.
+    \value WriteLock A write lock.
+    \value NoLock Neither a read lock nor a write lock.
+*/
+
+/*!
+    Constructs an unlocked \e QtLockedFile object. This constructor
+    behaves in the same way as \e QFile::QFile().
+
+    \sa QFile::QFile()
+*/
+QtLockedFile::QtLockedFile()
+    : QFile()
+{
+#ifdef Q_OS_WIN
+    wmutex = 0;
+    rmutex = 0;
+#endif
+    m_lock_mode = NoLock;
+}
+
+/*!
+    Constructs an unlocked QtLockedFile object with file \a name. This
+    constructor behaves in the same way as \e QFile::QFile(const
+    QString&).
+
+    \sa QFile::QFile()
+*/
+QtLockedFile::QtLockedFile(const QString &name)
+    : QFile(name)
+{
+#ifdef Q_OS_WIN
+    wmutex = 0;
+    rmutex = 0;
+#endif
+    m_lock_mode = NoLock;
+}
+
+/*!
+  Opens the file in OpenMode \a mode.
+
+  This is identical to QFile::open(), with the one exception that the
+  Truncate mode flag is disallowed. Truncation would conflict with the
+  advisory file locking, since the file would be modified before the
+  write lock is obtained. If truncation is required, use resize(0)
+  after obtaining the write lock.
+
+  Returns true if successful; otherwise false.
+
+  \sa QFile::open(), QFile::resize()
+*/
+bool QtLockedFile::open(OpenMode mode)
+{
+    if (mode & QIODevice::Truncate) {
+        qWarning("QtLockedFile::open(): Truncate mode not allowed.");
+        return false;
+    }
+    return QFile::open(mode);
+}
+
+/*!
+    Returns \e true if this object has a in read or write lock;
+    otherwise returns \e false.
+
+    \sa lockMode()
+*/
+bool QtLockedFile::isLocked() const
+{
+    return m_lock_mode != NoLock;
+}
+
+/*!
+    Returns the type of lock currently held by this object, or \e
+    QtLockedFile::NoLock.
+
+    \sa isLocked()
+*/
+QtLockedFile::LockMode QtLockedFile::lockMode() const
+{
+    return m_lock_mode;
+}
+
+/*!
+    \fn bool QtLockedFile::lock(LockMode mode, bool block = true)
+
+    Obtains a lock of type \a mode. The file must be opened before it
+    can be locked.
+
+    If \a block is true, this function will block until the lock is
+    aquired. If \a block is false, this function returns \e false
+    immediately if the lock cannot be aquired.
+
+    If this object already has a lock of type \a mode, this function
+    returns \e true immediately. If this object has a lock of a
+    different type than \a mode, the lock is first released and then a
+    new lock is obtained.
+
+    This function returns \e true if, after it executes, the file is
+    locked by this object, and \e false otherwise.
+
+    \sa unlock(), isLocked(), lockMode()
+*/
+
+/*!
+    \fn bool QtLockedFile::unlock()
+
+    Releases a lock.
+
+    If the object has no lock, this function returns immediately.
+
+    This function returns \e true if, after it executes, the file is
+    not locked by this object, and \e false otherwise.
+
+    \sa lock(), isLocked(), lockMode()
+*/
+
+/*!
+    \fn QtLockedFile::~QtLockedFile()
+
+    Destroys the \e QtLockedFile object. If any locks were held, they
+    are released.
+*/

src/app/qtsingleapplication/qtlockedfile.h

@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTLOCKEDFILE_H
+#define QTLOCKEDFILE_H
+
+#include <QFile>
+#ifdef Q_OS_WIN
+#include <QVector>
+#endif
+
+#if defined(Q_OS_WIN)
+#  if !defined(QT_QTLOCKEDFILE_EXPORT) && !defined(QT_QTLOCKEDFILE_IMPORT)
+#    define QT_QTLOCKEDFILE_EXPORT
+#  elif defined(QT_QTLOCKEDFILE_IMPORT)
+#    if defined(QT_QTLOCKEDFILE_EXPORT)
+#      undef QT_QTLOCKEDFILE_EXPORT
+#    endif
+#    define QT_QTLOCKEDFILE_EXPORT __declspec(dllimport)
+#  elif defined(QT_QTLOCKEDFILE_EXPORT)
+#    undef QT_QTLOCKEDFILE_EXPORT
+#    define QT_QTLOCKEDFILE_EXPORT __declspec(dllexport)
+#  endif
+#else
+#  define QT_QTLOCKEDFILE_EXPORT
+#endif
+
+namespace QtLP_Private {
+
+class QT_QTLOCKEDFILE_EXPORT QtLockedFile : public QFile
+{
+public:
+    enum LockMode { NoLock = 0, ReadLock, WriteLock };
+
+    QtLockedFile();
+    QtLockedFile(const QString &name);
+    ~QtLockedFile();
+
+    bool open(OpenMode mode);
+
+    bool lock(LockMode mode, bool block = true);
+    bool unlock();
+    bool isLocked() const;
+    LockMode lockMode() const;
+
+private:
+#ifdef Q_OS_WIN
+    Qt::HANDLE wmutex;
+    Qt::HANDLE rmutex;
+    QVector<Qt::HANDLE> rmutexes;
+    QString mutexname;
+
+    Qt::HANDLE getMutexHandle(int idx, bool doCreate);
+    bool waitMutex(Qt::HANDLE mutex, bool doBlock);
+
+#endif
+    LockMode m_lock_mode;
+};
+}
+#endif

src/app/qtsingleapplication/qtlockedfile_unix.cpp

@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "qtlockedfile.h"
+
+bool QtLockedFile::lock(LockMode mode, bool block)
+{
+    if (!isOpen()) {
+        qWarning("QtLockedFile::lock(): file is not opened");
+        return false;
+    }
+ 
+    if (mode == NoLock)
+        return unlock();
+           
+    if (mode == m_lock_mode)
+        return true;
+
+    if (m_lock_mode != NoLock)
+        unlock();
+
+    struct flock fl;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
+    fl.l_type = (mode == ReadLock) ? F_RDLCK : F_WRLCK;
+    int cmd = block ? F_SETLKW : F_SETLK;
+    int ret = fcntl(handle(), cmd, &fl);
+    
+    if (ret == -1) {
+        if (errno != EINTR && errno != EAGAIN)
+            qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
+        return false;
+    }
+
+    
+    m_lock_mode = mode;
+    return true;
+}
+
+
+bool QtLockedFile::unlock()
+{
+    if (!isOpen()) {
+        qWarning("QtLockedFile::unlock(): file is not opened");
+        return false;
+    }
+
+    if (!isLocked())
+        return true;
+
+    struct flock fl;
+    fl.l_whence = SEEK_SET;
+    fl.l_start = 0;
+    fl.l_len = 0;
+    fl.l_type = F_UNLCK;
+    int ret = fcntl(handle(), F_SETLKW, &fl);
+    
+    if (ret == -1) {
+        qWarning("QtLockedFile::lock(): fcntl: %s", strerror(errno));
+        return false;
+    }
+    
+    m_lock_mode = NoLock;
+    return true;
+}
+
+QtLockedFile::~QtLockedFile()
+{
+    if (isOpen())
+        unlock();
+}
+

src/app/qtsingleapplication/qtlockedfile_win.cpp

@@ -0,0 +1,211 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtlockedfile.h"
+#include <qt_windows.h>
+#include <QFileInfo>
+
+#define MUTEX_PREFIX "QtLockedFile mutex "
+// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS
+#define MAX_READERS MAXIMUM_WAIT_OBJECTS
+
+#if QT_VERSION >= 0x050000
+#define QT_WA(unicode, ansi) unicode
+#endif
+
+Qt::HANDLE QtLockedFile::getMutexHandle(int idx, bool doCreate)
+{
+    if (mutexname.isEmpty()) {
+        QFileInfo fi(*this);
+        mutexname = QString::fromLatin1(MUTEX_PREFIX)
+                    + fi.absoluteFilePath().toLower();
+    }
+    QString mname(mutexname);
+    if (idx >= 0)
+        mname += QString::number(idx);
+
+    Qt::HANDLE mutex;
+    if (doCreate) {
+        QT_WA( { mutex = CreateMutexW(NULL, FALSE, (TCHAR*)mname.utf16()); },
+               { mutex = CreateMutexA(NULL, FALSE, mname.toLocal8Bit().constData()); } );
+        if (!mutex) {
+            qErrnoWarning("QtLockedFile::lock(): CreateMutex failed");
+            return 0;
+        }
+    }
+    else {
+        QT_WA( { mutex = OpenMutexW(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, (TCHAR*)mname.utf16()); },
+               { mutex = OpenMutexA(SYNCHRONIZE | MUTEX_MODIFY_STATE, FALSE, mname.toLocal8Bit().constData()); } );
+        if (!mutex) {
+            if (GetLastError() != ERROR_FILE_NOT_FOUND)
+                qErrnoWarning("QtLockedFile::lock(): OpenMutex failed");
+            return 0;
+        }
+    }
+    return mutex;
+}
+
+bool QtLockedFile::waitMutex(Qt::HANDLE mutex, bool doBlock)
+{
+    Q_ASSERT(mutex);
+    DWORD res = WaitForSingleObject(mutex, doBlock ? INFINITE : 0);
+    switch (res) {
+    case WAIT_OBJECT_0:
+    case WAIT_ABANDONED:
+        return true;
+        break;
+    case WAIT_TIMEOUT:
+        break;
+    default:
+        qErrnoWarning("QtLockedFile::lock(): WaitForSingleObject failed");
+    }
+    return false;
+}
+
+
+
+bool QtLockedFile::lock(LockMode mode, bool block)
+{
+    if (!isOpen()) {
+        qWarning("QtLockedFile::lock(): file is not opened");
+        return false;
+    }
+
+    if (mode == NoLock)
+        return unlock();
+
+    if (mode == m_lock_mode)
+        return true;
+
+    if (m_lock_mode != NoLock)
+        unlock();
+
+    if (!wmutex && !(wmutex = getMutexHandle(-1, true)))
+        return false;
+
+    if (!waitMutex(wmutex, block))
+        return false;
+
+    if (mode == ReadLock) {
+        int idx = 0;
+        for (; idx < MAX_READERS; idx++) {
+            rmutex = getMutexHandle(idx, false);
+            if (!rmutex || waitMutex(rmutex, false))
+                break;
+            CloseHandle(rmutex);
+        }
+        bool ok = true;
+        if (idx >= MAX_READERS) {
+            qWarning("QtLockedFile::lock(): too many readers");
+            rmutex = 0;
+            ok = false;
+        }
+        else if (!rmutex) {
+            rmutex = getMutexHandle(idx, true);
+            if (!rmutex || !waitMutex(rmutex, false))
+                ok = false;
+        }
+        if (!ok && rmutex) {
+            CloseHandle(rmutex);
+            rmutex = 0;
+        }
+        ReleaseMutex(wmutex);
+        if (!ok)
+            return false;
+    }
+    else {
+        Q_ASSERT(rmutexes.isEmpty());
+        for (int i = 0; i < MAX_READERS; i++) {
+            Qt::HANDLE mutex = getMutexHandle(i, false);
+            if (mutex)
+                rmutexes.append(mutex);
+        }
+        if (rmutexes.size()) {
+            DWORD res = WaitForMultipleObjects(rmutexes.size(), rmutexes.constData(),
+                                               TRUE, block ? INFINITE : 0);
+            if (res != WAIT_OBJECT_0 && res != WAIT_ABANDONED) {
+                if (res != WAIT_TIMEOUT)
+                    qErrnoWarning("QtLockedFile::lock(): WaitForMultipleObjects failed");
+                m_lock_mode = WriteLock;  // trick unlock() to clean up - semiyucky
+                unlock();
+                return false;
+            }
+        }
+    }
+
+    m_lock_mode = mode;
+    return true;
+}
+
+bool QtLockedFile::unlock()
+{
+    if (!isOpen()) {
+        qWarning("QtLockedFile::unlock(): file is not opened");
+        return false;
+    }
+
+    if (!isLocked())
+        return true;
+
+    if (m_lock_mode == ReadLock) {
+        ReleaseMutex(rmutex);
+        CloseHandle(rmutex);
+        rmutex = 0;
+    }
+    else {
+        foreach(Qt::HANDLE mutex, rmutexes) {
+            ReleaseMutex(mutex);
+            CloseHandle(mutex);
+        }
+        rmutexes.clear();
+        ReleaseMutex(wmutex);
+    }
+
+    m_lock_mode = QtLockedFile::NoLock;
+    return true;
+}
+
+QtLockedFile::~QtLockedFile()
+{
+    if (isOpen())
+        unlock();
+    if (wmutex)
+        CloseHandle(wmutex);
+}

src/app/qtsingleapplication/qtsingleapplication.cpp

@@ -0,0 +1,353 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtsingleapplication.h"
+#include "qtlocalpeer.h"
+#include <QWidget>
+
+
+/*!
+    \class QtSingleApplication qtsingleapplication.h
+    \brief The QtSingleApplication class provides an API to detect and
+    communicate with running instances of an application.
+
+    This class allows you to create applications where only one
+    instance should be running at a time. I.e., if the user tries to
+    launch another instance, the already running instance will be
+    activated instead. Another usecase is a client-server system,
+    where the first started instance will assume the role of server,
+    and the later instances will act as clients of that server.
+
+    By default, the full path of the executable file is used to
+    determine whether two processes are instances of the same
+    application. You can also provide an explicit identifier string
+    that will be compared instead.
+
+    The application should create the QtSingleApplication object early
+    in the startup phase, and call isRunning() to find out if another
+    instance of this application is already running. If isRunning()
+    returns false, it means that no other instance is running, and
+    this instance has assumed the role as the running instance. In
+    this case, the application should continue with the initialization
+    of the application user interface before entering the event loop
+    with exec(), as normal.
+
+    The messageReceived() signal will be emitted when the running
+    application receives messages from another instance of the same
+    application. When a message is received it might be helpful to the
+    user to raise the application so that it becomes visible. To
+    facilitate this, QtSingleApplication provides the
+    setActivationWindow() function and the activateWindow() slot.
+
+    If isRunning() returns true, another instance is already
+    running. It may be alerted to the fact that another instance has
+    started by using the sendMessage() function. Also data such as
+    startup parameters (e.g. the name of the file the user wanted this
+    new instance to open) can be passed to the running instance with
+    this function. Then, the application should terminate (or enter
+    client mode).
+
+    If isRunning() returns true, but sendMessage() fails, that is an
+    indication that the running instance is frozen.
+
+    Here's an example that shows how to convert an existing
+    application to use QtSingleApplication. It is very simple and does
+    not make use of all QtSingleApplication's functionality (see the
+    examples for that).
+
+    \code
+    // Original
+    int main(int argc, char **argv)
+    {
+        QApplication app(argc, argv);
+
+        MyMainWidget mmw;
+        mmw.show();
+        return app.exec();
+    }
+
+    // Single instance
+    int main(int argc, char **argv)
+    {
+        QtSingleApplication app(argc, argv);
+
+        if (app.isRunning())
+            return !app.sendMessage(someDataString);
+
+        MyMainWidget mmw;
+        app.setActivationWindow(&mmw);
+        mmw.show();
+        return app.exec();
+    }
+    \endcode
+
+    Once this QtSingleApplication instance is destroyed (normally when
+    the process exits or crashes), when the user next attempts to run the
+    application this instance will not, of course, be encountered. The
+    next instance to call isRunning() or sendMessage() will assume the
+    role as the new running instance.
+
+    For console (non-GUI) applications, QtSingleCoreApplication may be
+    used instead of this class, to avoid the dependency on the QtGui
+    library.
+
+    \sa QtSingleCoreApplication
+*/
+
+
+void QtSingleApplication::sysInit(const QString &appId)
+{
+    actWin = 0;
+    peer = new QtLocalPeer(this, appId);
+    connect(peer, SIGNAL(messageReceived(const QString&)), SIGNAL(messageReceived(const QString&)));
+}
+
+
+/*!
+    Creates a QtSingleApplication object. The application identifier
+    will be QCoreApplication::applicationFilePath(). \a argc, \a
+    argv, and \a GUIenabled are passed on to the QAppliation constructor.
+
+    If you are creating a console application (i.e. setting \a
+    GUIenabled to false), you may consider using
+    QtSingleCoreApplication instead.
+*/
+
+QtSingleApplication::QtSingleApplication(int &argc, char **argv, bool GUIenabled)
+    : QApplication(argc, argv, GUIenabled)
+{
+    sysInit();
+}
+
+
+/*!
+    Creates a QtSingleApplication object with the application
+    identifier \a appId. \a argc and \a argv are passed on to the
+    QAppliation constructor.
+*/
+
+QtSingleApplication::QtSingleApplication(const QString &appId, int &argc, char **argv)
+    : QApplication(argc, argv)
+{
+    sysInit(appId);
+}
+
+#if QT_VERSION < 0x050000
+
+/*!
+    Creates a QtSingleApplication object. The application identifier
+    will be QCoreApplication::applicationFilePath(). \a argc, \a
+    argv, and \a type are passed on to the QAppliation constructor.
+*/
+QtSingleApplication::QtSingleApplication(int &argc, char **argv, Type type)
+    : QApplication(argc, argv, type)
+{
+    sysInit();
+}
+
+
+#  if defined(Q_WS_X11)
+/*!
+  Special constructor for X11, ref. the documentation of
+  QApplication's corresponding constructor. The application identifier
+  will be QCoreApplication::applicationFilePath(). \a dpy, \a visual,
+  and \a cmap are passed on to the QApplication constructor.
+*/
+QtSingleApplication::QtSingleApplication(Display* dpy, Qt::HANDLE visual, Qt::HANDLE cmap)
+    : QApplication(dpy, visual, cmap)
+{
+    sysInit();
+}
+
+/*!
+  Special constructor for X11, ref. the documentation of
+  QApplication's corresponding constructor. The application identifier
+  will be QCoreApplication::applicationFilePath(). \a dpy, \a argc, \a
+  argv, \a visual, and \a cmap are passed on to the QApplication
+  constructor.
+*/
+QtSingleApplication::QtSingleApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual, Qt::HANDLE cmap)
+    : QApplication(dpy, argc, argv, visual, cmap)
+{
+    sysInit();
+}
+
+/*!
+  Special constructor for X11, ref. the documentation of
+  QApplication's corresponding constructor. The application identifier
+  will be \a appId. \a dpy, \a argc, \a
+  argv, \a visual, and \a cmap are passed on to the QApplication
+  constructor.
+*/
+QtSingleApplication::QtSingleApplication(Display* dpy, const QString &appId, int argc, char **argv, Qt::HANDLE visual, Qt::HANDLE cmap)
+    : QApplication(dpy, argc, argv, visual, cmap)
+{
+    sysInit(appId);
+}
+#  endif // Q_WS_X11
+#endif // QT_VERSION < 0x050000
+
+
+/*!
+    Returns true if another instance of this application is running;
+    otherwise false.
+
+    This function does not find instances of this application that are
+    being run by a different user (on Windows: that are running in
+    another session).
+
+    \sa sendMessage()
+*/
+
+bool QtSingleApplication::isRunning()
+{
+    return peer->isClient();
+}
+
+
+/*!
+    Tries to send the text \a message to the currently running
+    instance. The QtSingleApplication object in the running instance
+    will emit the messageReceived() signal when it receives the
+    message.
+
+    This function returns true if the message has been sent to, and
+    processed by, the current instance. If there is no instance
+    currently running, or if the running instance fails to process the
+    message within \a timeout milliseconds, this function return false.
+
+    \sa isRunning(), messageReceived()
+*/
+bool QtSingleApplication::sendMessage(const QString &message, int timeout)
+{
+    return peer->sendMessage(message, timeout);
+}
+
+
+/*!
+    Returns the application identifier. Two processes with the same
+    identifier will be regarded as instances of the same application.
+*/
+QString QtSingleApplication::id() const
+{
+    return peer->applicationId();
+}
+
+
+/*!
+  Sets the activation window of this application to \a aw. The
+  activation window is the widget that will be activated by
+  activateWindow(). This is typically the application's main window.
+
+  If \a activateOnMessage is true (the default), the window will be
+  activated automatically every time a message is received, just prior
+  to the messageReceived() signal being emitted.
+
+  \sa activateWindow(), messageReceived()
+*/
+
+void QtSingleApplication::setActivationWindow(QWidget* aw, bool activateOnMessage)
+{
+    actWin = aw;
+    if (activateOnMessage)
+        connect(peer, SIGNAL(messageReceived(const QString&)), this, SLOT(activateWindow()));
+    else
+        disconnect(peer, SIGNAL(messageReceived(const QString&)), this, SLOT(activateWindow()));
+}
+
+
+/*!
+    Returns the applications activation window if one has been set by
+    calling setActivationWindow(), otherwise returns 0.
+
+    \sa setActivationWindow()
+*/
+QWidget* QtSingleApplication::activationWindow() const
+{
+    return actWin;
+}
+
+
+/*!
+  De-minimizes, raises, and activates this application's activation window.
+  This function does nothing if no activation window has been set.
+
+  This is a convenience function to show the user that this
+  application instance has been activated when he has tried to start
+  another instance.
+
+  This function should typically be called in response to the
+  messageReceived() signal. By default, that will happen
+  automatically, if an activation window has been set.
+
+  \sa setActivationWindow(), messageReceived(), initialize()
+*/
+void QtSingleApplication::activateWindow()
+{
+    if (actWin) {
+        actWin->setWindowState(actWin->windowState() & ~Qt::WindowMinimized);
+        actWin->raise();
+        actWin->activateWindow();
+    }
+}
+
+
+/*!
+    \fn void QtSingleApplication::messageReceived(const QString& message)
+
+    This signal is emitted when the current instance receives a \a
+    message from another instance of this application.
+
+    \sa sendMessage(), setActivationWindow(), activateWindow()
+*/
+
+
+/*!
+    \fn void QtSingleApplication::initialize(bool dummy = true)
+
+    \obsolete
+*/
+
+#ifdef Q_OS_WIN
+qint64 QtSingleApplication::getRunningPid() {
+  return peer->getRunningPid();
+}
+#endif

src/app/qtsingleapplication/qtsingleapplication.h

@@ -0,0 +1,109 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTSINGLEAPPLICATION_H
+#define QTSINGLEAPPLICATION_H
+
+#include <QApplication>
+
+class QtLocalPeer;
+
+#if defined(Q_OS_WIN)
+#  if !defined(QT_QTSINGLEAPPLICATION_EXPORT) && !defined(QT_QTSINGLEAPPLICATION_IMPORT)
+#    define QT_QTSINGLEAPPLICATION_EXPORT
+#  elif defined(QT_QTSINGLEAPPLICATION_IMPORT)
+#    if defined(QT_QTSINGLEAPPLICATION_EXPORT)
+#      undef QT_QTSINGLEAPPLICATION_EXPORT
+#    endif
+#    define QT_QTSINGLEAPPLICATION_EXPORT __declspec(dllimport)
+#  elif defined(QT_QTSINGLEAPPLICATION_EXPORT)
+#    undef QT_QTSINGLEAPPLICATION_EXPORT
+#    define QT_QTSINGLEAPPLICATION_EXPORT __declspec(dllexport)
+#  endif
+#else
+#  define QT_QTSINGLEAPPLICATION_EXPORT
+#endif
+
+class QT_QTSINGLEAPPLICATION_EXPORT QtSingleApplication : public QApplication
+{
+    Q_OBJECT
+
+public:
+    QtSingleApplication(int &argc, char **argv, bool GUIenabled = true);
+    QtSingleApplication(const QString &id, int &argc, char **argv);
+#if QT_VERSION < 0x050000
+    QtSingleApplication(int &argc, char **argv, Type type);
+#  if defined(Q_WS_X11)
+    QtSingleApplication(Display* dpy, Qt::HANDLE visual = 0, Qt::HANDLE colormap = 0);
+    QtSingleApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE cmap= 0);
+    QtSingleApplication(Display* dpy, const QString &appId, int argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE colormap = 0);
+#  endif // Q_WS_X11
+#endif // QT_VERSION < 0x050000
+
+    bool isRunning();
+    QString id() const;
+
+    void setActivationWindow(QWidget* aw, bool activateOnMessage = true);
+    QWidget* activationWindow() const;
+
+    // Obsolete:
+    void initialize(bool dummy = true)
+        { isRunning(); Q_UNUSED(dummy) }
+#ifdef Q_OS_WIN
+#define QBT_HAS_GETCURRENTPID
+    qint64 getRunningPid();
+#endif
+
+public Q_SLOTS:
+    bool sendMessage(const QString &message, int timeout = 5000);
+    void activateWindow();
+
+
+Q_SIGNALS:
+    void messageReceived(const QString &message);
+
+
+private:
+    void sysInit(const QString &appId = QString());
+    QtLocalPeer *peer;
+    QWidget *actWin;
+};
+
+#endif // QTSINGLEAPPLICATION_H

src/app/qtsingleapplication/qtsingleapplication.pri

@@ -0,0 +1,16 @@
+INCLUDEPATH += $$PWD
+DEPENDPATH += $$PWD
+QT *= network
+greaterThan(QT_MAJOR_VERSION, 4): QT *= widgets
+
+qtsingleapplication-uselib:!qtsingleapplication-buildlib {
+    LIBS += -L$$QTSINGLEAPPLICATION_LIBDIR -l$$QTSINGLEAPPLICATION_LIBNAME
+} else {
+    SOURCES += $$PWD/qtsingleapplication.cpp $$PWD/qtlocalpeer.cpp
+    HEADERS += $$PWD/qtsingleapplication.h $$PWD/qtlocalpeer.h
+}
+
+win32 {
+    contains(TEMPLATE, lib):contains(CONFIG, shared):DEFINES += QT_QTSINGLEAPPLICATION_EXPORT
+    else:qtsingleapplication-uselib:DEFINES += QT_QTSINGLEAPPLICATION_IMPORT
+}

src/app/qtsingleapplication/qtsinglecoreapplication.cpp

@@ -0,0 +1,149 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include "qtsinglecoreapplication.h"
+#include "qtlocalpeer.h"
+
+/*!
+    \class QtSingleCoreApplication qtsinglecoreapplication.h
+    \brief A variant of the QtSingleApplication class for non-GUI applications.
+
+    This class is a variant of QtSingleApplication suited for use in
+    console (non-GUI) applications. It is an extension of
+    QCoreApplication (instead of QApplication). It does not require
+    the QtGui library.
+
+    The API and usage is identical to QtSingleApplication, except that
+    functions relating to the "activation window" are not present, for
+    obvious reasons. Please refer to the QtSingleApplication
+    documentation for explanation of the usage.
+
+    A QtSingleCoreApplication instance can communicate to a
+    QtSingleApplication instance if they share the same application
+    id. Hence, this class can be used to create a light-weight
+    command-line tool that sends commands to a GUI application.
+
+    \sa QtSingleApplication
+*/
+
+/*!
+    Creates a QtSingleCoreApplication object. The application identifier
+    will be QCoreApplication::applicationFilePath(). \a argc and \a
+    argv are passed on to the QCoreAppliation constructor.
+*/
+
+QtSingleCoreApplication::QtSingleCoreApplication(int &argc, char **argv)
+    : QCoreApplication(argc, argv)
+{
+    peer = new QtLocalPeer(this);
+    connect(peer, SIGNAL(messageReceived(const QString&)), SIGNAL(messageReceived(const QString&)));
+}
+
+
+/*!
+    Creates a QtSingleCoreApplication object with the application
+    identifier \a appId. \a argc and \a argv are passed on to the
+    QCoreAppliation constructor.
+*/
+QtSingleCoreApplication::QtSingleCoreApplication(const QString &appId, int &argc, char **argv)
+    : QCoreApplication(argc, argv)
+{
+    peer = new QtLocalPeer(this, appId);
+    connect(peer, SIGNAL(messageReceived(const QString&)), SIGNAL(messageReceived(const QString&)));
+}
+
+
+/*!
+    Returns true if another instance of this application is running;
+    otherwise false.
+
+    This function does not find instances of this application that are
+    being run by a different user (on Windows: that are running in
+    another session).
+
+    \sa sendMessage()
+*/
+
+bool QtSingleCoreApplication::isRunning()
+{
+    return peer->isClient();
+}
+
+
+/*!
+    Tries to send the text \a message to the currently running
+    instance. The QtSingleCoreApplication object in the running instance
+    will emit the messageReceived() signal when it receives the
+    message.
+
+    This function returns true if the message has been sent to, and
+    processed by, the current instance. If there is no instance
+    currently running, or if the running instance fails to process the
+    message within \a timeout milliseconds, this function return false.
+
+    \sa isRunning(), messageReceived()
+*/
+
+bool QtSingleCoreApplication::sendMessage(const QString &message, int timeout)
+{
+    return peer->sendMessage(message, timeout);
+}
+
+
+/*!
+    Returns the application identifier. Two processes with the same
+    identifier will be regarded as instances of the same application.
+*/
+
+QString QtSingleCoreApplication::id() const
+{
+    return peer->applicationId();
+}
+
+
+/*!
+    \fn void QtSingleCoreApplication::messageReceived(const QString& message)
+
+    This signal is emitted when the current instance receives a \a
+    message from another instance of this application.
+
+    \sa sendMessage()
+*/

src/app/qtsingleapplication/qtsinglecoreapplication.h

@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Solutions component.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QTSINGLECOREAPPLICATION_H
+#define QTSINGLECOREAPPLICATION_H
+
+#include <QCoreApplication>
+
+class QtLocalPeer;
+
+class QtSingleCoreApplication : public QCoreApplication
+{
+    Q_OBJECT
+
+public:
+    QtSingleCoreApplication(int &argc, char **argv);
+    QtSingleCoreApplication(const QString &id, int &argc, char **argv);
+
+    bool isRunning();
+    QString id() const;
+
+public Q_SLOTS:
+    bool sendMessage(const QString &message, int timeout = 5000);
+
+
+Q_SIGNALS:
+    void messageReceived(const QString &message);
+
+
+private:
+    QtLocalPeer* peer;
+};
+
+#endif // QTSINGLECOREAPPLICATION_H

src/app/qtsingleapplication/qtsinglecoreapplication.pri

@@ -0,0 +1,10 @@
+INCLUDEPATH	+= $$PWD
+DEPENDPATH      += $$PWD
+HEADERS		+= $$PWD/qtsinglecoreapplication.h $$PWD/qtlocalpeer.h
+SOURCES		+= $$PWD/qtsinglecoreapplication.cpp $$PWD/qtlocalpeer.cpp
+
+QT *= network
+
+win32:contains(TEMPLATE, lib):contains(CONFIG, shared) {
+    DEFINES += QT_QTSINGLECOREAPPLICATION_EXPORT=__declspec(dllexport)
+}

src/app/sessionapplication.cpp

@@ -0,0 +1,50 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2010  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#include <QDebug>
+#include "sessionapplication.h"
+
+SessionApplication::SessionApplication(const QString &id, int &argc, char **argv) :
+#ifdef Q_OS_MAC
+QMacApplication(id, argc, argv)
+#else
+QtSingleApplication(id, argc, argv)
+#endif
+{}
+
+bool SessionApplication::notify(QObject* receiver, QEvent* event) {
+  try {
+    return QApplication::notify(receiver, event);
+  } catch(const std::exception& e) {
+    qCritical() << "Exception thrown:" << e.what() << ", receiver: " << receiver->objectName();
+    receiver->dumpObjectInfo();
+  }
+  return false;
+}

src/app/sessionapplication.h

@@ -0,0 +1,60 @@
+/*
+ * Bittorrent Client using Qt4 and libtorrent.
+ * Copyright (C) 2010  Christophe Dumez
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ *
+ * Contact : chris@qbittorrent.org
+ */
+
+#ifndef SESSIONAPPLICATION_H
+#define SESSIONAPPLICATION_H
+
+#include <QtCore/QtGlobal>
+
+#ifdef Q_OS_MAC
+#include "qmacapplication.h"
+#else
+#include "qtsingleapplication.h"
+#endif
+
+#include <QSessionManager>
+
+class SessionApplication :
+#ifdef Q_OS_MAC
+    public QMacApplication
+#else
+    public QtSingleApplication
+#endif
+{
+  Q_OBJECT
+
+public:
+  SessionApplication(const QString &id, int &argc, char **argv);
+
+protected:
+    virtual bool notify(QObject* receiver, QEvent* event);
+};
+
+#endif // SESSIONAPPLICATION_H

src/app/stacktrace.h

@@ -0,0 +1,94 @@
+// stacktrace.h (c) 2008, Timo Bingmann from http://idlebox.net/
+// published under the WTFPL v2.0
+
+#ifndef _STACKTRACE_H_
+#define _STACKTRACE_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <execinfo.h>
+#include <cxxabi.h>
+
+/** Print a demangled stack backtrace of the caller function to FILE* out. */
+static inline void print_stacktrace(FILE *out = stderr, unsigned int max_frames = 63)
+{
+    fprintf(out, "stack trace:\n");
+
+    // storage array for stack trace address data
+    void* addrlist[max_frames+1];
+
+    // retrieve current stack addresses
+    int addrlen = backtrace(addrlist, sizeof(addrlist) / sizeof(void*));
+
+    if (addrlen == 0) {
+	fprintf(out, "  <empty, possibly corrupt>\n");
+	return;
+    }
+
+    // resolve addresses into strings containing "filename(function+address)",
+    // this array must be free()-ed
+    char** symbollist = backtrace_symbols(addrlist, addrlen);
+
+    // allocate string which will be filled with the demangled function name
+    size_t funcnamesize = 256;
+    char* funcname = (char*)malloc(funcnamesize);
+
+    // iterate over the returned symbol lines. skip the first, it is the
+    // address of this function.
+    for (int i = 2; i < addrlen; i++)
+    {
+	char *begin_name = 0, *begin_offset = 0, *end_offset = 0;
+
+	// find parentheses and +address offset surrounding the mangled name:
+	// ./module(function+0x15c) [0x8048a6d]
+	//fprintf(out, "%s TT\n", symbollist[i]);
+	for (char *p = symbollist[i]; *p; ++p)
+	{
+	    if (*p == '(')
+		begin_name = p;
+	    else if (*p == '+')
+		begin_offset = p;
+	    else if (*p == ')' && begin_offset) {
+		end_offset = p;
+		break;
+	    }
+	}
+
+	if (begin_name && begin_offset && end_offset
+	    && begin_name < begin_offset)
+	{
+	    *begin_name++ = '\0';
+	    *begin_offset++ = '\0';
+	    *end_offset = '\0';
+
+	    // mangled name is now in [begin_name, begin_offset) and caller
+	    // offset in [begin_offset, end_offset). now apply
+	    // __cxa_demangle():
+
+	    int status;
+	    char* ret = abi::__cxa_demangle(begin_name,
+					    funcname, &funcnamesize, &status);
+	    if (status == 0) {
+		funcname = ret; // use possibly realloc()-ed string
+		fprintf(out, "  %s : %s+%s %s\n",
+			symbollist[i], funcname, begin_offset, ++end_offset);
+	    }
+	    else {
+		// demangling failed. Output function name as a C function with
+		// no arguments.
+		fprintf(out, "  %s : %s()+%s %s\n",
+			symbollist[i], begin_name, begin_offset, ++end_offset);
+	    }
+	}
+	else
+	{
+	    // couldn't parse the line? print the whole line.
+	    fprintf(out, "  %s\n", symbollist[i]);
+	}
+    }
+
+    free(funcname);
+    free(symbollist);
+}
+
+#endif // _STACKTRACE_H_

src/app/stacktrace_win.h

@@ -0,0 +1,268 @@
+/***************************************************************************
+*   Copyright (C) 2005-09 by the Quassel Project                          *
+*   devel@quassel-irc.org                                                 *
+*                                                                         *
+*   This program is free software; you can redistribute it and/or modify  *
+*   it under the terms of the GNU General Public License as published by  *
+*   the Free Software Foundation; either version 2 of the License, or     *
+*   (at your option) version 3.                                           *
+*                                                                         *
+*   This program is distributed in the hope that it will be useful,       *
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+*   GNU General Public License for more details.                          *
+*                                                                         *
+*   You should have received a copy of the GNU General Public License     *
+*   along with this program; if not, write to the                         *
+*   Free Software Foundation, Inc.,                                       *
+*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+***************************************************************************/
+
+#include <windows.h>
+#include <dbghelp.h>
+#include <stdio.h>
+
+#include <QTextStream>
+#ifdef __MINGW32__
+#include <cxxabi.h>
+#endif
+
+namespace straceWin
+{
+    void loadHelpStackFrame(IMAGEHLP_STACK_FRAME&, const STACKFRAME64&);
+    BOOL CALLBACK EnumSymbolsCB(PSYMBOL_INFO, ULONG, PVOID);
+    BOOL CALLBACK EnumModulesCB(LPCSTR, DWORD64, PVOID);
+    const QString getBacktrace();
+    struct EnumModulesContext;
+    // Also works for MinGW64
+#ifdef __MINGW32__
+    void demangle(QString& str);
+#endif
+}
+
+#ifdef __MINGW32__
+void straceWin::demangle(QString& str)
+{
+    char const* inStr = qPrintable("_" + str); // Really need that underline or demangling will fail
+    int status = 0;
+    size_t outSz = 0;
+    char* demangled_name = abi::__cxa_demangle(inStr, 0, &outSz, &status);
+    if (status == 0) {
+        str = QString::fromLocal8Bit(demangled_name);
+        if (outSz > 0)
+            free(demangled_name);
+    }
+}
+#endif
+
+void straceWin::loadHelpStackFrame(IMAGEHLP_STACK_FRAME& ihsf, const STACKFRAME64& stackFrame)
+{
+    ZeroMemory(&ihsf, sizeof(IMAGEHLP_STACK_FRAME));
+    ihsf.InstructionOffset = stackFrame.AddrPC.Offset;
+    ihsf.FrameOffset = stackFrame.AddrFrame.Offset;
+}
+
+BOOL CALLBACK straceWin::EnumSymbolsCB(PSYMBOL_INFO symInfo, ULONG size, PVOID user)
+{
+    Q_UNUSED(size)
+    QStringList* params = (QStringList*)user;
+    if (symInfo->Flags & SYMFLAG_PARAMETER)
+        params->append(symInfo->Name);
+    return TRUE;
+}
+
+
+struct straceWin::EnumModulesContext
+{
+    HANDLE hProcess;
+    QTextStream& stream;
+    EnumModulesContext(HANDLE hProcess, QTextStream& stream): hProcess(hProcess), stream(stream) {}
+};
+
+BOOL CALLBACK straceWin::EnumModulesCB(LPCSTR ModuleName, DWORD64 BaseOfDll, PVOID UserContext)
+{
+    Q_UNUSED(ModuleName)
+    IMAGEHLP_MODULE64 mod;
+    EnumModulesContext* context = (EnumModulesContext*)UserContext;
+    mod.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+    if(SymGetModuleInfo64(context->hProcess, BaseOfDll, &mod)) {
+        QString moduleBase = QString("0x%1").arg(BaseOfDll, 16, 16, QLatin1Char('0'));
+        QString line = QString("%1 %2 Image: %3")
+                       .arg(mod.ModuleName, -25)
+                       .arg(moduleBase, -13)
+                       .arg(mod.LoadedImageName);
+        context->stream << line << '\n';
+
+        QString pdbName(mod.LoadedPdbName);
+        if(!pdbName.isEmpty()) {
+            QString line2 = QString("%1 %2")
+                            .arg("", 35)
+                            .arg(pdbName);
+            context->stream << line2 << '\n';
+        }
+    }
+    return TRUE;
+}
+
+
+
+#if defined( _M_IX86 ) && defined(Q_CC_MSVC)
+// Disable global optimization and ignore /GS waning caused by
+// inline assembly.
+// not needed with mingw cause we can tell mingw which registers we use
+#pragma optimize("g", off)
+#pragma warning(push)
+#pragma warning(disable : 4748)
+#endif
+const QString straceWin::getBacktrace()
+{
+    DWORD MachineType;
+    CONTEXT Context;
+    STACKFRAME64 StackFrame;
+
+#ifdef _M_IX86
+    ZeroMemory(&Context, sizeof(CONTEXT));
+    Context.ContextFlags = CONTEXT_CONTROL;
+
+
+#ifdef __MINGW32__
+    asm ("Label:\n\t"
+         "movl %%ebp,%0;\n\t"
+         "movl %%esp,%1;\n\t"
+         "movl $Label,%%eax;\n\t"
+         "movl %%eax,%2;\n\t"
+         : "=r" (Context.Ebp),"=r" (Context.Esp),"=r" (Context.Eip)
+         : //no input
+         : "eax");
+#else
+    _asm {
+        Label:
+        mov [Context.Ebp], ebp;
+        mov [Context.Esp], esp;
+        mov eax, [Label];
+        mov [Context.Eip], eax;
+    }
+#endif
+#else
+    RtlCaptureContext(&Context);
+#endif
+
+    ZeroMemory(&StackFrame, sizeof(STACKFRAME64));
+#ifdef _M_IX86
+    MachineType                 = IMAGE_FILE_MACHINE_I386;
+    StackFrame.AddrPC.Offset    = Context.Eip;
+    StackFrame.AddrPC.Mode      = AddrModeFlat;
+    StackFrame.AddrFrame.Offset = Context.Ebp;
+    StackFrame.AddrFrame.Mode   = AddrModeFlat;
+    StackFrame.AddrStack.Offset = Context.Esp;
+    StackFrame.AddrStack.Mode   = AddrModeFlat;
+#elif _M_X64
+    MachineType                 = IMAGE_FILE_MACHINE_AMD64;
+    StackFrame.AddrPC.Offset    = Context.Rip;
+    StackFrame.AddrPC.Mode      = AddrModeFlat;
+    StackFrame.AddrFrame.Offset = Context.Rsp;
+    StackFrame.AddrFrame.Mode   = AddrModeFlat;
+    StackFrame.AddrStack.Offset = Context.Rsp;
+    StackFrame.AddrStack.Mode   = AddrModeFlat;
+#elif _M_IA64
+    MachineType                 = IMAGE_FILE_MACHINE_IA64;
+    StackFrame.AddrPC.Offset    = Context.StIIP;
+    StackFrame.AddrPC.Mode      = AddrModeFlat;
+    StackFrame.AddrFrame.Offset = Context.IntSp;
+    StackFrame.AddrFrame.Mode   = AddrModeFlat;
+    StackFrame.AddrBStore.Offset = Context.RsBSP;
+    StackFrame.AddrBStore.Mode  = AddrModeFlat;
+    StackFrame.AddrStack.Offset = Context.IntSp;
+    StackFrame.AddrStack.Mode   = AddrModeFlat;
+#else
+#error "Unsupported platform"
+#endif
+
+    QString log;
+    QTextStream logStream(&log);
+    logStream << "```\n";
+
+    HANDLE hProcess = GetCurrentProcess();
+    HANDLE hThread = GetCurrentThread();
+    SymInitialize(hProcess, NULL, TRUE);
+
+    DWORD64 dwDisplacement;
+
+    ULONG64 buffer[(sizeof(SYMBOL_INFO) +
+                    MAX_SYM_NAME * sizeof(TCHAR) +
+                    sizeof(ULONG64) - 1) /  sizeof(ULONG64)];
+    PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
+    pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+    pSymbol->MaxNameLen = MAX_SYM_NAME;
+
+    IMAGEHLP_MODULE64 mod;
+    mod.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+
+    IMAGEHLP_STACK_FRAME ihsf;
+    ZeroMemory(&ihsf, sizeof(IMAGEHLP_STACK_FRAME));
+
+    int i = 0;
+
+    while(StackWalk64(MachineType, hProcess, hThread, &StackFrame, &Context, NULL, NULL, NULL, NULL)) {
+        if(i == 128)
+            break;
+
+        loadHelpStackFrame(ihsf, StackFrame);
+        if(StackFrame.AddrPC.Offset != 0) { // Valid frame.
+
+            QString fileName("???");
+            if(SymGetModuleInfo64(hProcess, ihsf.InstructionOffset, &mod)) {
+                fileName = QString(mod.ImageName);
+                int slashPos = fileName.lastIndexOf('\\');
+                if(slashPos != -1)
+                    fileName = fileName.mid(slashPos + 1);
+            }
+            QString funcName;
+            if(SymFromAddr(hProcess, ihsf.InstructionOffset, &dwDisplacement, pSymbol)) {
+                funcName = QString(pSymbol->Name);
+#ifdef __MINGW32__
+                demangle(funcName);
+#endif
+            }
+            else {
+                funcName = QString("0x%1").arg(ihsf.InstructionOffset, 8, 16, QLatin1Char('0'));
+            }
+            SymSetContext(hProcess, &ihsf, NULL);
+#ifndef __MINGW32__
+            QStringList params;
+            SymEnumSymbols(hProcess, 0, NULL, EnumSymbolsCB, (PVOID)&params);
+#endif
+
+            QString insOffset = QString("0x%1").arg(ihsf.InstructionOffset, 16, 16, QLatin1Char('0'));
+            QString formatLine = "#%1 %2 %3 %4";
+#ifndef __MINGW32__
+            formatLine += "(%5)";
+#endif
+            QString debugLine = formatLine
+                                .arg(i, 3, 10)
+                                .arg(fileName, -20)
+                                .arg(insOffset, -11)
+                                .arg(funcName)
+#ifndef __MINGW32__
+                                .arg(params.join(", "));
+#else
+                                ;
+#endif
+            logStream << debugLine << '\n';
+            i++;
+        }
+        else {
+            break; // we're at the end.
+        }
+    }
+
+    logStream << "\n\nList of linked Modules:\n";
+    EnumModulesContext modulesContext(hProcess, logStream);
+    SymEnumerateModules64(hProcess, EnumModulesCB, (PVOID)&modulesContext);
+    logStream << "```";
+    return log;
+}
+#if defined(_M_IX86) && defined(Q_CC_MSVC)
+#pragma warning(pop)
+#pragma optimize("g", on)
+#endif

src/app/stacktrace_win_dlg.h

@@ -0,0 +1,54 @@
+#ifndef STACKTRACE_WIN_DLG_H
+#define STACKTRACE_WIN_DLG_H
+
+#include <QTextStream>
+#include <QClipboard>
+#include "boost/version.hpp"
+#include "libtorrent/version.hpp"
+#include "ui_stacktrace_win_dlg.h"
+
+class StraceDlg: public QDialog, private Ui::errorDialog
+{
+    Q_OBJECT
+
+public:
+    StraceDlg(QWidget* parent = 0): QDialog(parent)
+    {
+        setupUi(this);
+    }
+
+    ~StraceDlg()
+    {
+    }
+
+    void setStacktraceString(const QString& trace)
+    {
+        QString htmlStr;
+        QTextStream outStream(&htmlStr);
+        outStream << "<p align=center><b><font size=7 color=red>" <<
+            "qBittorrent has crashed" <<
+            "</font></b></p>" <<
+            "<font size=4>" <<
+            "<p>" <<
+            "Please report a bug at <a href=\"http://bugs.qbittorrent.org\">" <<
+            "http://bugs.qbittorrent.org</a>" <<
+            " and provide the following backtrace." <<
+            "</p>" <<
+            "</font>" <<
+            "<br/><hr><br/>" <<
+            "<p align=center><font size=4>qBittorrent version: " << VERSION <<
+            "<br/>Libtorrent version: " << LIBTORRENT_VERSION <<
+            "<br/>Qt version: " << QT_VERSION_STR <<
+            "<br/>Boost version: " << QString::number(BOOST_VERSION / 100000) << '.' <<
+            QString::number((BOOST_VERSION / 100) % 1000) << '.' <<
+            QString::number(BOOST_VERSION % 100) << "</font></p><br/>"
+            "<pre><code>" <<
+            trace <<
+            "</code></pre>" <<
+            "<br/><hr><br/><br/>";
+
+        errorText->setHtml(htmlStr);
+    }
+};
+
+#endif

src/app/stacktrace_win_dlg.ui

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>errorDialog</class>
+ <widget class="QDialog" name="errorDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>640</width>
+    <height>480</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Crash info</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QTextBrowser" name="errorText">
+     <property name="html">
+      <string notr="true">&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
+p, li { white-space: pre-wrap; }
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot;-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;&quot;&gt;&lt;br /&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+     <property name="openExternalLinks">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>