1 files changed, 46 insertions, 30 deletions

diff --git a/singleapplication.cpp b/singleapplication.cpp
index 0bcbc12..27e2bb1 100644
--- a/singleapplication.cpp
+++ b/singleapplication.cpp
@@ -1,34 +1,41 @@
-#include "singleapplication.h"
-#include <QSharedMemory>
-#include <QLocalSocket>
-#include <QLocalServer>
-#include <QMutex>
 #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();
-        server->removeServer(serverName);
+        QLocalServer::removeServer(serverName);
         server->listen(serverName);
-        QObject::connect(server, SIGNAL(newConnection()), q_ptr, SLOT(slotConnectionEstablished()));
+        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
+        // instances of SingleApplication in different threads.
+        // Which in my opinion is idiotic, but lets handle that too.
         {
             sharedMemMutex.lock();
             sharedMem.append(memory);
@@ -38,9 +45,9 @@ public:
         // 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(SIGFPE,  SingleApplicationPrivate::terminate);
+        signal(SIGILL,  SingleApplicationPrivate::terminate);
+        signal(SIGINT,  SingleApplicationPrivate::terminate);
         signal(SIGTERM, SingleApplicationPrivate::terminate);
     }
 
@@ -75,38 +82,43 @@ public:
  * @param argv
  */
 SingleApplication::SingleApplication(int &argc, char *argv[])
-    : QAPPLICATION_CLASS(argc, argv), d_ptr(new SingleApplicationPrivate(this))
+    : app_t(argc, argv), d_ptr(new SingleApplicationPrivate(this))
 {
-    QString serverName = QAPPLICATION_CLASS::organizationName() + QAPPLICATION_CLASS::applicationName();
+    Q_D(SingleApplication);
+
+    QString serverName = app_t::organizationName() + app_t::applicationName();
     serverName.replace(QRegExp("[^\\w\\-. ]"), "");
 
-    // Garantee thread safe behaviour with a shared memory block
-    d_ptr->memory = new QSharedMemory(serverName);
+    // 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_ptr->memory->create(1, QSharedMemory::ReadOnly) )
+    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_ptr->crashHandler();
+        d->crashHandler();
 #endif
         // Successful creation means that no main process exists
         // So we start a Local Server to listen for connections
-        d_ptr->startServer(serverName);
+        d->startServer(serverName);
     } else {
         // Connect to the Local Server of the main process to notify it
         // that a new process had been started
-        d_ptr->socket = new QLocalSocket();
-        d_ptr->socket->connectToServer(serverName);
+        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_ptr->socket->waitForConnected(100) )
+        // 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) )
         {
-            ::exit(EXIT_SUCCESS); // Terminate the program using STDLib's exit function
+            // Terminate the program using STDLib's exit function
+            ::exit(EXIT_SUCCESS);
         } else {
-            delete d_ptr->memory;
+            delete d->memory;
             ::exit(EXIT_SUCCESS);
         }
     }
@@ -117,8 +129,10 @@ SingleApplication::SingleApplication(int &argc, char *argv[])
  */
 SingleApplication::~SingleApplication()
 {
-    delete d_ptr->memory;
-    d_ptr->server->close();
+    Q_D(SingleApplication);
+
+    delete d->memory;
+    d->server->close();
 }
 
 /**
@@ -126,8 +140,10 @@ SingleApplication::~SingleApplication()
  */
 void SingleApplication::slotConnectionEstablished()
 {
-    QLocalSocket *socket = d_ptr->server->nextPendingConnection();
+    Q_D(SingleApplication);
+
+    QLocalSocket *socket = d->server->nextPendingConnection();
     socket->close();
     delete socket;
-    emit showUp();
+    Q_EMIT showUp();
 }