Page MenuHomePhabricator (Chris)
Files F86170

No OneTemporary
Actions

Size
8 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/README.md b/README.md
index 754e6b4..f677ba6 100644
--- a/README.md
+++ b/README.md
@@ -1,68 +1,69 @@
SingleApplication
=================
This is a replacement of the QSingleApplication for `Qt5`.
Keeps the Primary Instance of your Application and kills each subsequent instances.
Usage
-----
The `SingleApplication` class inherits from whatever `Q[Core|Gui]Application` class you specify in the `*.pro` file. Further usage is similar to use one of the `Q[Core|Gui]Application` classes.
The library uses your `Organization Name` and `Application Name` to set up a `QLocalServer` and a `QSharedMemory` block. The first instance of your Application would check if the shared memory block exists and if not it will start a `QLocalServer` and then listen for connections on it. Each subsequent instance of your application would check if the shared memory block exists and if it does, it will connect to the QLocalServer to notify it that a new instance had been started, after which would terminate the new instance with status code `0`. The Primary Instance, `SingleApplication` would emmit the `showUp()` signal upon detecting that a new instance had been started.
The library uses `stdlib` to terminate the program with the `exit()` function.
Here is an example usage of the library:
```cpp
// project.pro
DEFINES += QAPPLICATION_CLASS=QApplication # or whatever app class you want
// main.cpp
#include "singleapplication.h"
int main(int argc, char *argv[])
{
QApplication::setApplicationName("{Your App Name}");
QApplication::setOrganizationName("{Your Organization Name}");
SingleApplication app(argc, argv);
return app.exec();
}
```
The `Show Up` signal
------------------------
The SingleApplication class implements a `showUp()` signal. You can bind to that signal to raise your application's window when a new instance had been started.
Note that since `SingleApplication` extends the `QApplication` class you can do the following:
```cpp
// Truly raise your window.
-QObject::connect(&app, &SingleApplication::showUp, [&]{
- window.show();
- window.raise();
- window.activateWindow();
- }); // 'window' is your QWindow instance
+QObject::connect(&app, &SingleApplication::showUp, [&]
+{
+ window.show();
+ window.raise();
+ window.activateWindow();
+}); // 'window' is your QWindow instance
```
Using `QApplication::instance()` is a neat way to get the `SingleApplication` instance at any place in your program.
Implementation
--------------
The library is implemented with a QSharedMemory block which is thread safe and guarantees a race condition will not occur. It also uses a QLocalSocket to notify the main process that a new instance had been spawned and thus invoke the `showUp()` signal.
To handle an issue on `*nix` systems, where the operating system owns the shared memory block and if the program crashes the memory remains untouched, the library binds to the following signals and closes the program with error code = `128 + signum` where signum is the number representation of the signal listed below. Handling the signal is required in order to safely delete the `QSharedMemory` block.
* `SIGINT ` - `2`
* `SIGILL ` - `4`
* `SIGABRT` - `6`
* `SIGFPE ` - `8`
* `SIGSEGV` - `11`
* `SIGTERM` - `15`
License
-------
This library and it's supporting documentation are released under `The MIT License (MIT)`.
diff --git a/singleapplication.cpp b/singleapplication.cpp
index 1c0d921..27e2bb1 100644
--- a/singleapplication.cpp
+++ b/singleapplication.cpp
@@ -1,149 +1,149 @@
#include <cstdlib>
#include <QtCore/QSharedMemory>
#include <QtCore/QMutex>
#include <QtNetwork/QLocalSocket>
#include <QtNetwork/QLocalServer>
#ifdef Q_OS_UNIX
#include <signal.h>
#include <unistd.h>
#endif
#include "singleapplication.h"
class SingleApplicationPrivate {
Q_DECLARE_PUBLIC(SingleApplication)
public:
SingleApplicationPrivate(SingleApplication *q_ptr) : q_ptr(q_ptr) { }
void startServer(QString &serverName)
{
Q_Q(SingleApplication);
// Start a QLocalServer to listen for connections
server = new QLocalServer();
QLocalServer::removeServer(serverName);
server->listen(serverName);
QObject::connect(server, SIGNAL(newConnection()), q, SLOT(slotConnectionEstablished()));
}
#ifdef Q_OS_UNIX
void crashHandler()
{
// This guarantees the program will work even with multiple
// instances of SingleApplication in different threads.
// Which in my opinion is idiotic, but lets handle that too.
{
sharedMemMutex.lock();
sharedMem.append(memory);
sharedMemMutex.unlock();
}
// Handle any further termination signals to ensure the
// QSharedMemory block is deleted even if the process crashes
signal(SIGSEGV, SingleApplicationPrivate::terminate);
signal(SIGABRT, SingleApplicationPrivate::terminate);
signal(SIGFPE, SingleApplicationPrivate::terminate);
signal(SIGILL, SingleApplicationPrivate::terminate);
signal(SIGINT, SingleApplicationPrivate::terminate);
signal(SIGTERM, SingleApplicationPrivate::terminate);
}
static void terminate(int signum)
{
while( ! sharedMem.empty() ) {
delete sharedMem.back();
sharedMem.pop_back();
}
::exit(128 + signum);
}
static QList<QSharedMemory*> sharedMem;
static QMutex sharedMemMutex;
#endif
QSharedMemory *memory;
SingleApplication *q_ptr;
QLocalServer *server;
QLocalSocket *socket;
};
#ifdef Q_OS_UNIX
QList<QSharedMemory*> SingleApplicationPrivate::sharedMem;
QMutex SingleApplicationPrivate::sharedMemMutex;
#endif
/**
* @brief Constructor. Checks and fires up LocalServer or closes the program
* if another instance already exists
* @param argc
* @param argv
*/
SingleApplication::SingleApplication(int &argc, char *argv[])
: app_t(argc, argv), d_ptr(new SingleApplicationPrivate(this))
{
Q_D(SingleApplication);
QString serverName = app_t::organizationName() + app_t::applicationName();
serverName.replace(QRegExp("[^\\w\\-. ]"), "");
// Guarantee thread safe behaviour with a shared memory block
d->memory = new QSharedMemory(serverName);
// Create a shared memory block with a minimum size of 1 byte
if( d->memory->create(1, QSharedMemory::ReadOnly) )
{
#ifdef Q_OS_UNIX
// Handle any further termination signals to ensure the
// QSharedMemory block is deleted even if the process crashes
d->crashHandler();
#endif
// Successful creation means that no main process exists
// So we start a Local Server to listen for connections
d->startServer(serverName);
} else {
// Connect to the Local Server of the main process to notify it
// that a new process had been started
d->socket = new QLocalSocket();
d->socket->connectToServer(serverName);
// Even though a shared memory block exists, the original application
// might have crashed.
// So only after a successful connection is the second instance
// terminated.
if( d->socket->waitForConnected(100) )
{
- // Terminate the program using STDLib's exit function.
+ // Terminate the program using STDLib's exit function
::exit(EXIT_SUCCESS);
} else {
delete d->memory;
::exit(EXIT_SUCCESS);
}
}
}
/**
* @brief Destructor
*/
SingleApplication::~SingleApplication()
{
Q_D(SingleApplication);
delete d->memory;
d->server->close();
}
/**
* @brief Executed when the showUp command is sent to LocalServer
*/
void SingleApplication::slotConnectionEstablished()
{
Q_D(SingleApplication);
QLocalSocket *socket = d->server->nextPendingConnection();
socket->close();
delete socket;
Q_EMIT showUp();
}
diff --git a/singleapplication.h b/singleapplication.h
index dc6beb3..91f5b11 100644
--- a/singleapplication.h
+++ b/singleapplication.h
@@ -1,36 +1,40 @@
#ifndef SINGLE_APPLICATION_H
#define SINGLE_APPLICATION_H
#include <QtCore/QtGlobal>
+#ifndef QAPPLICATION_CLASS
+ #define QAPPLICATION_CLASS QApplication
+#endif
+
#include QT_STRINGIFY(QAPPLICATION_CLASS)
class SingleApplicationPrivate;
/**
* @brief The SingleApplication class handles multipe instances of the same Application
* @see QApplication
*/
class SingleApplication : public QAPPLICATION_CLASS
{
Q_OBJECT
Q_DECLARE_PRIVATE(SingleApplication)
typedef QAPPLICATION_CLASS app_t;
public:
explicit SingleApplication(int&, char *[]);
~SingleApplication();
Q_SIGNALS:
void showUp();
private Q_SLOTS:
void slotConnectionEstablished();
private:
SingleApplicationPrivate *d_ptr;
};
#endif // SINGLE_APPLICATION_H

File Metadata

Mime Type
text/x-diff
Expires
Thu, Sep 11, 7:10 PM (1 d, 1 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
42706
Default Alt Text
(8 KB)

Event Timeline