Eliminate the "q_ptr->" call by using Q_Q(QSerialPort)

Unfortunately, the q_ptr data member cannot yet be deleted from the internal
data class because QIODevicePrivate would need to be inherited then. That is not
a simple change considering the Qt4 support. Hence, that part of the logic is
put on hold, but can be expected in an upcoming change at some point, soon.

Change-Id: Ic8ba9621dd647f4afa1b91d01c858c836d1cc0c8
Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com>
Reviewed-by: Sergey Belyashov <Sergey.Belyashov@gmail.com>

7 files changed, 139 insertions, 61 deletions

diff --git a/src/serialport/qserialport_symbian.cpp b/src/serialport/qserialport_symbian.cpp
index af3859b..df348b8 100644
--- a/src/serialport/qserialport_symbian.cpp
+++ b/src/serialport/qserialport_symbian.cpp
@@ -102,18 +102,20 @@ QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
 
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
+    Q_Q(QSerialPort);
+
     // FIXME: Maybe need added check an ReadWrite open mode?
     Q_UNUSED(mode)
 
     if (!loadDevices()) {
-        q_ptr->setError(QSerialPort::UnknownError);
+        q->setError(QSerialPort::UnknownError);
         return false;
     }
 
     RCommServ server;
     errnum = server.Connect();
     if (errnum != KErrNone) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -127,7 +129,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         errnum = server.LoadCommModule(KRS232ModuleName);
 
     if (errnum != KErrNone) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -136,14 +138,14 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
     errnum = descriptor.Open(server, portName, ECommExclusive);
 
     if (errnum != KErrNone) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
     // Save current port settings.
     errnum = descriptor.Config(restoredSettings);
     if (errnum != KErrNone) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -277,8 +279,10 @@ bool QSerialPortPrivate::waitForBytesWritten(int msec)
 
 bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
+    Q_Q(QSerialPort);
+
     if (dir != QSerialPort::AllDirections) {
-        q_ptr->setError(QSerialPort::UnsupportedOperationError);
+        q->setError(QSerialPort::UnsupportedOperationError);
         return false;
     }
 
@@ -286,7 +290,7 @@ bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions di
     if (baudRate)
         currentSettings().iRate = static_cast<TBps>(baudRate);
     else {
-        q_ptr->setError(QSerialPort::UnsupportedOperationError);
+        q->setError(QSerialPort::UnsupportedOperationError);
         return false;
     }
 
@@ -399,8 +403,10 @@ bool QSerialPortPrivate::notifyWrite()
 
 bool QSerialPortPrivate::updateCommConfig()
 {
+    Q_Q(QSerialPort);
+
     if (descriptor.SetConfig(currentSettings) != KErrNone) {
-        q_ptr->setError(QSerialPort::UnsupportedOperationError);
+        q->setError(QSerialPort::UnsupportedOperationError);
         return false;
     }
     return true;
diff --git a/src/serialport/qserialport_symbian_p.h b/src/serialport/qserialport_symbian_p.h
index 411661d..d709236 100644
--- a/src/serialport/qserialport_symbian_p.h
+++ b/src/serialport/qserialport_symbian_p.h
@@ -50,6 +50,8 @@ QT_BEGIN_NAMESPACE
 
 class QSerialPortPrivate : public QSerialPortPrivateData
 {
+    Q_DECLARE_PUBLIC(QSerialPort)
+
 public:
     QSerialPortPrivate(QSerialPort *q);
 
diff --git a/src/serialport/qserialport_unix.cpp b/src/serialport/qserialport_unix.cpp
index 42ad21d..93d01a6 100644
--- a/src/serialport/qserialport_unix.cpp
+++ b/src/serialport/qserialport_unix.cpp
@@ -139,12 +139,14 @@ QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
 
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
+    Q_Q(QSerialPort);
+
     QByteArray portName = portNameFromSystemLocation(systemLocation).toLocal8Bit();
     const char *ptr = portName.constData();
 
     bool byCurrPid = false;
     if (QTtyLocker::isLocked(ptr, &byCurrPid)) {
-        q_ptr->setError(QSerialPort::PermissionError);
+        q->setError(QSerialPort::PermissionError);
         return false;
     }
 
@@ -165,7 +167,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
     descriptor = ::open(systemLocation.toLocal8Bit().constData(), flags);
 
     if (descriptor == -1) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -173,7 +175,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 
     QTtyLocker::lock(ptr);
     if (!QTtyLocker::isLocked(ptr, &byCurrPid)) {
-        q_ptr->setError(QSerialPort::PermissionError);
+        q->setError(QSerialPort::PermissionError);
         return false;
     }
 
@@ -182,7 +184,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 #endif
 
     if (::tcgetattr(descriptor, &restoredTermios) == -1) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -254,11 +256,13 @@ void QSerialPortPrivate::close()
 
 QSerialPort::PinoutSignals QSerialPortPrivate::pinoutSignals()
 {
+    Q_Q(QSerialPort);
+
     int arg = 0;
     QSerialPort::PinoutSignals ret = QSerialPort::NoSignal;
 
     if (::ioctl(descriptor, TIOCMGET, &arg) == -1) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return ret;
     }
 
@@ -419,6 +423,8 @@ qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 
 bool QSerialPortPrivate::waitForReadyRead(int msecs)
 {
+    Q_Q(QSerialPort);
+
     QElapsedTimer stopWatch;
 
     stopWatch.start();
@@ -430,7 +436,7 @@ bool QSerialPortPrivate::waitForReadyRead(int msecs)
         if (!waitForReadOrWrite(&readyToRead, &readyToWrite, true, !writeBuffer.isEmpty(),
                                 timeoutValue(msecs, stopWatch.elapsed()), &timedOut)) {
             if (!timedOut)
-                q_ptr->setError(decodeSystemError());
+                q->setError(decodeSystemError());
             return false;
         }
 
@@ -448,6 +454,8 @@ bool QSerialPortPrivate::waitForReadyRead(int msecs)
 
 bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 {
+    Q_Q(QSerialPort);
+
     if (writeBuffer.isEmpty())
         return false;
 
@@ -462,7 +470,7 @@ bool QSerialPortPrivate::waitForBytesWritten(int msecs)
         if (!waitForReadOrWrite(&readyToRead, &readyToWrite, true, !writeBuffer.isEmpty(),
                                 timeoutValue(msecs, stopWatch.elapsed()), &timedOut)) {
             if (!timedOut)
-                q_ptr->setError(decodeSystemError());
+                q->setError(decodeSystemError());
             return false;
         }
 
@@ -477,6 +485,8 @@ bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 
 bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
+    Q_Q(QSerialPort);
+
     bool ret = baudRate > 0;
 
     // prepare section
@@ -541,7 +551,7 @@ bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions di
     if (ret) // finally, set baud rate
         ret = updateTermios();
     else
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
     return ret;
 }
 
@@ -679,6 +689,8 @@ bool QSerialPortPrivate::setDataErrorPolicy(QSerialPort::DataErrorPolicy policy)
 
 bool QSerialPortPrivate::readNotification()
 {
+    Q_Q(QSerialPort);
+
     // Prevent recursive calls
     if (readPortNotifierCalled) {
         if (!readPortNotifierStateSet) {
@@ -724,7 +736,7 @@ bool QSerialPortPrivate::readNotification()
 
     if (!emittedReadyRead && hasData) {
         emittedReadyRead = true;
-        emit q_ptr->readyRead();
+        emit q->readyRead();
         emittedReadyRead = false;
     }
 
@@ -743,6 +755,8 @@ bool QSerialPortPrivate::readNotification()
 
 bool QSerialPortPrivate::writeNotification(int maxSize)
 {
+    Q_Q(QSerialPort);
+
     const int tmp = writeBuffer.size();
 
     if (writeBuffer.isEmpty()) {
@@ -765,7 +779,7 @@ bool QSerialPortPrivate::writeNotification(int maxSize)
         // Don't emit bytesWritten() recursively.
         if (!emittedBytesWritten) {
             emittedBytesWritten = true;
-            emit q_ptr->bytesWritten(written);
+            emit q->bytesWritten(written);
             emittedBytesWritten = false;
         }
     }
@@ -778,16 +792,20 @@ bool QSerialPortPrivate::writeNotification(int maxSize)
 
 bool QSerialPortPrivate::exceptionNotification()
 {
+    Q_Q(QSerialPort);
+
     QSerialPort::SerialPortError error = decodeSystemError();
-    q_ptr->setError(error);
+    q->setError(error);
 
     return true;
 }
 
 bool QSerialPortPrivate::updateTermios()
 {
+    Q_Q(QSerialPort);
+
     if (::tcsetattr(descriptor, TCSANOW, &currentTermios) == -1) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
     return true;
@@ -924,10 +942,12 @@ bool QSerialPortPrivate::isReadNotificationEnabled() const
 
 void QSerialPortPrivate::setReadNotificationEnabled(bool enable)
 {
+    Q_Q(QSerialPort);
+
     if (readNotifier) {
         readNotifier->setEnabled(enable);
     } else if (enable) {
-        readNotifier = new ReadNotifier(this, q_ptr);
+        readNotifier = new ReadNotifier(this, q);
         readNotifier->setEnabled(true);
     }
 }
@@ -939,10 +959,12 @@ bool QSerialPortPrivate::isWriteNotificationEnabled() const
 
 void QSerialPortPrivate::setWriteNotificationEnabled(bool enable)
 {
+    Q_Q(QSerialPort);
+
     if (writeNotifier) {
         writeNotifier->setEnabled(enable);
     } else if (enable) {
-        writeNotifier = new WriteNotifier(this, q_ptr);
+        writeNotifier = new WriteNotifier(this, q);
         writeNotifier->setEnabled(true);
     }
 }
@@ -954,10 +976,12 @@ bool QSerialPortPrivate::isExceptionNotificationEnabled() const
 
 void QSerialPortPrivate::setExceptionNotificationEnabled(bool enable)
 {
+    Q_Q(QSerialPort);
+
     if (exceptionNotifier) {
         exceptionNotifier->setEnabled(enable);
     } else if (enable) {
-        exceptionNotifier = new ExceptionNotifier(this, q_ptr);
+        exceptionNotifier = new ExceptionNotifier(this, q);
         exceptionNotifier->setEnabled(true);
     }
 }
@@ -1000,6 +1024,8 @@ bool QSerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectFor
 
 qint64 QSerialPortPrivate::readFromPort(char *data, qint64 maxSize)
 {
+    Q_Q(QSerialPort);
+
     qint64 bytesRead = 0;
 #if defined (CMSPAR)
     if (parity == QSerialPort::NoParity
@@ -1017,7 +1043,7 @@ qint64 QSerialPortPrivate::readFromPort(char *data, qint64 maxSize)
         QSerialPort::SerialPortError error = decodeSystemError();
         if (error != QSerialPort::ResourceError)
             error = QSerialPort::ReadError;
-        q_ptr->setError(error);
+        q->setError(error);
     }
 
     return bytesRead;
@@ -1025,6 +1051,8 @@ qint64 QSerialPortPrivate::readFromPort(char *data, qint64 maxSize)
 
 qint64 QSerialPortPrivate::writeToPort(const char *data, qint64 maxSize)
 {
+    Q_Q(QSerialPort);
+
     qint64 bytesWritten = 0;
 #if defined (CMSPAR)
     bytesWritten = ::write(descriptor, data, maxSize);
@@ -1041,7 +1069,7 @@ qint64 QSerialPortPrivate::writeToPort(const char *data, qint64 maxSize)
         QSerialPort::SerialPortError error = decodeSystemError();
         if (error != QSerialPort::ResourceError)
             error = QSerialPort::WriteError;
-        q_ptr->setError(error);
+        q->setError(error);
     }
 
     return bytesWritten;
@@ -1090,6 +1118,8 @@ qint64 QSerialPortPrivate::writePerChar(const char *data, qint64 maxSize)
 
 qint64 QSerialPortPrivate::readPerChar(char *data, qint64 maxSize)
 {
+    Q_Q(QSerialPort);
+
     qint64 ret = 0;
     quint8 const charMask = (0xFF >> (8 - dataBits));
 
@@ -1137,9 +1167,9 @@ qint64 QSerialPortPrivate::readPerChar(char *data, qint64 maxSize)
                 continue;       //ignore received character
             case QSerialPort::StopReceivingPolicy:
                 if (parity != QSerialPort::NoParity)
-                    q_ptr->setError(QSerialPort::ParityError);
+                    q->setError(QSerialPort::ParityError);
                 else
-                    q_ptr->setError(*data == '\0' ?
+                    q->setError(*data == '\0' ?
                                 QSerialPort::BreakConditionError : QSerialPort::FramingError);
                 return ++ret;   //abort receiving
                 break;
diff --git a/src/serialport/qserialport_unix_p.h b/src/serialport/qserialport_unix_p.h
index eeb0017..d75bc90 100644
--- a/src/serialport/qserialport_unix_p.h
+++ b/src/serialport/qserialport_unix_p.h
@@ -57,6 +57,8 @@ class QSocketNotifier;
 
 class QSerialPortPrivate : public QSerialPortPrivateData
 {
+    Q_DECLARE_PUBLIC(QSerialPort)
+
 public:
     QSerialPortPrivate(QSerialPort *q);
 
diff --git a/src/serialport/qserialport_win.cpp b/src/serialport/qserialport_win.cpp
index 9a4f778..f0b5e96 100644
--- a/src/serialport/qserialport_win.cpp
+++ b/src/serialport/qserialport_win.cpp
@@ -227,6 +227,8 @@ QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
 
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
+    Q_Q(QSerialPort);
+
     DWORD desiredAccess = 0;
     DWORD originalEventMask = EV_ERR;
 
@@ -241,12 +243,12 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
                               desiredAccess, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
 
     if (descriptor == INVALID_HANDLE_VALUE) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
     if (!::GetCommState(descriptor, &restoredDcb)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -262,7 +264,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         return false;
 
     if (!::GetCommTimeouts(descriptor, &restoredCommTimeouts)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -273,11 +275,11 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         return false;
 
     if (originalEventMask & EV_RXCHAR) {
-        QWinEventNotifier *n = new ReadOverlappedCompletionNotifier(this, q_ptr);
+        QWinEventNotifier *n = new ReadOverlappedCompletionNotifier(this, q);
         n->setEnabled(true);
     }
 
-    QWinEventNotifier *n = new CommOverlappedEventNotifier(this, originalEventMask, q_ptr);
+    QWinEventNotifier *n = new CommOverlappedEventNotifier(this, originalEventMask, q);
     n->setEnabled(true);
 
     detectDefaultSettings();
@@ -315,11 +317,13 @@ void QSerialPortPrivate::close()
 
 QSerialPort::PinoutSignals QSerialPortPrivate::pinoutSignals()
 {
+    Q_Q(QSerialPort);
+
     DWORD modemStat = 0;
     QSerialPort::PinoutSignals ret = QSerialPort::NoSignal;
 
     if (!::GetCommModemStatus(descriptor, &modemStat)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return ret;
     }
 
@@ -470,6 +474,8 @@ qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 
 bool QSerialPortPrivate::waitForReadyRead(int msecs)
 {
+    Q_Q(QSerialPort);
+
     QElapsedTimer stopWatch;
     stopWatch.start();
 
@@ -480,7 +486,7 @@ bool QSerialPortPrivate::waitForReadyRead(int msecs)
         if (!waitAnyEvent(timeoutValue(msecs, stopWatch.elapsed()), &timedOut, &n) || !n) {
             // This is occur timeout or another error
             if (!timedOut)
-                q_ptr->setError(decodeSystemError());
+                q->setError(decodeSystemError());
             return false;
         }
 
@@ -504,6 +510,8 @@ bool QSerialPortPrivate::waitForReadyRead(int msecs)
 
 bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 {
+    Q_Q(QSerialPort);
+
     if (writeBuffer.isEmpty())
         return false;
 
@@ -516,7 +524,7 @@ bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 
         if (!waitAnyEvent(timeoutValue(msecs, stopWatch.elapsed()), &timedOut, &n) || !n) {
             if (!timedOut)
-                q_ptr->setError(decodeSystemError());
+                q->setError(decodeSystemError());
             return false;
         }
 
@@ -540,8 +548,10 @@ bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 
 bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
+    Q_Q(QSerialPort);
+
     if (dir != QSerialPort::AllDirections) {
-        q_ptr->setError(QSerialPort::UnsupportedOperationError);
+        q->setError(QSerialPort::UnsupportedOperationError);
         return false;
     }
     currentDcb.BaudRate = baudRate;
@@ -634,6 +644,8 @@ bool QSerialPortPrivate::setDataErrorPolicy(QSerialPort::DataErrorPolicy policy)
 
 bool QSerialPortPrivate::startAsyncRead()
 {
+    Q_Q(QSerialPort);
+
     DWORD bytesToRead = policy == QSerialPort::IgnorePolicy ? ReadChunkSize : 1;
 
     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
@@ -647,7 +659,7 @@ bool QSerialPortPrivate::startAsyncRead()
 
     AbstractOverlappedEventNotifier *n = lookupReadCompletionNotifier();
     if (!n) {
-        q_ptr->setError(QSerialPort::ResourceError);
+        q->setError(QSerialPort::ResourceError);
         return false;
     }
 
@@ -660,7 +672,7 @@ bool QSerialPortPrivate::startAsyncRead()
     if (error != QSerialPort::NoError) {
         if (error != QSerialPort::ResourceError)
             error = QSerialPort::ReadError;
-        q_ptr->setError(error);
+        q->setError(error);
 
         readBuffer.truncate(actualReadBufferSize);
         return false;
@@ -671,6 +683,8 @@ bool QSerialPortPrivate::startAsyncRead()
 
 bool QSerialPortPrivate::startAsyncWrite(int maxSize)
 {
+    Q_Q(QSerialPort);
+
     qint64 nextSize = 0;
     const char *ptr = writeBuffer.readPointerAtPosition(acyncWritePosition, nextSize);
 
@@ -685,7 +699,7 @@ bool QSerialPortPrivate::startAsyncWrite(int maxSize)
 
     AbstractOverlappedEventNotifier *n = lookupFreeWriteCompletionNotifier();
     if (!n) {
-        q_ptr->setError(QSerialPort::ResourceError);
+        q->setError(QSerialPort::ResourceError);
         return false;
     }
 
@@ -701,7 +715,7 @@ bool QSerialPortPrivate::startAsyncWrite(int maxSize)
          if (error != QSerialPort::ResourceError)
              error = QSerialPort::WriteError;
 
-         q_ptr->setError(error);
+         q->setError(error);
          return false;
     }
 
@@ -712,8 +726,10 @@ bool QSerialPortPrivate::startAsyncWrite(int maxSize)
 
 bool QSerialPortPrivate::processIoErrors(bool error)
 {
+    Q_Q(QSerialPort);
+
     if (error) {
-        q_ptr->setError(QSerialPort::ResourceError);
+        q->setError(QSerialPort::ResourceError);
         return true;
     }
 
@@ -721,14 +737,14 @@ bool QSerialPortPrivate::processIoErrors(bool error)
     const bool ret = ::ClearCommError(descriptor, &errors, NULL);
     if (ret && errors) {
         if (errors & CE_FRAME) {
-            q_ptr->setError(QSerialPort::FramingError);
+            q->setError(QSerialPort::FramingError);
         } else if (errors & CE_RXPARITY) {
-            q_ptr->setError(QSerialPort::ParityError);
+            q->setError(QSerialPort::ParityError);
             parityErrorOccurred = true;
         } else if (errors & CE_BREAK) {
-            q_ptr->setError(QSerialPort::BreakConditionError);
+            q->setError(QSerialPort::BreakConditionError);
         } else {
-            q_ptr->setError(QSerialPort::UnknownError);
+            q->setError(QSerialPort::UnknownError);
         }
     }
     return ret;
@@ -738,6 +754,8 @@ bool QSerialPortPrivate::processIoErrors(bool error)
 
 bool QSerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
 {
+    Q_Q(QSerialPort);
+
     actualReadBufferSize += qint64(numberOfBytes);
     readBuffer.truncate(actualReadBufferSize);
 
@@ -758,7 +776,7 @@ bool QSerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
             // Abort receiving
             if (policy == QSerialPort::StopReceivingPolicy) {
                 readyReadEmitted = true;
-                emit q_ptr->readyRead();
+                emit q->readyRead();
                 return true;
             }
 
@@ -771,19 +789,21 @@ bool QSerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
         }
 
         readyReadEmitted = true;
-        emit q_ptr->readyRead();
+        emit q->readyRead();
     }
     return true;
 }
 
 bool QSerialPortPrivate::completeAsyncWrite(DWORD numberOfBytes)
 {
+    Q_Q(QSerialPort);
+
     writeBuffer.free(numberOfBytes);
     actualWriteBufferSize -= qint64(numberOfBytes);
     acyncWritePosition -= qint64(numberOfBytes);
 
     if (numberOfBytes > 0)
-        emit q_ptr->bytesWritten(numberOfBytes);
+        emit q->bytesWritten(numberOfBytes);
 
     if (writeBuffer.isEmpty())
         writeSequenceStarted = false;
@@ -795,6 +815,8 @@ bool QSerialPortPrivate::completeAsyncWrite(DWORD numberOfBytes)
 
 AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupFreeWriteCompletionNotifier()
 {
+    Q_Q(QSerialPort);
+
     // find first free not running write notifier
     foreach (AbstractOverlappedEventNotifier *n, notifiers) {
         if ((n->type() == AbstractOverlappedEventNotifier::WriteCompletionEvent)
@@ -803,7 +825,7 @@ AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupFreeWriteCompletionNo
         }
     }
     // if all write notifiers in use, then create new write notifier
-    return new WriteOverlappedCompletionNotifier(this, q_ptr);
+    return new WriteOverlappedCompletionNotifier(this, q);
 }
 
 AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupCommEventNotifier()
@@ -826,8 +848,10 @@ AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupReadCompletionNotifie
 
 bool QSerialPortPrivate::updateDcb()
 {
+    Q_Q(QSerialPort);
+
     if (!::SetCommState(descriptor, &currentDcb)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
     return true;
@@ -835,8 +859,10 @@ bool QSerialPortPrivate::updateDcb()
 
 bool QSerialPortPrivate::updateCommTimeouts()
 {
+    Q_Q(QSerialPort);
+
     if (!::SetCommTimeouts(descriptor, &currentCommTimeouts)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
     return true;
diff --git a/src/serialport/qserialport_win_p.h b/src/serialport/qserialport_win_p.h
index 5d0284d..9735e9f 100644
--- a/src/serialport/qserialport_win_p.h
+++ b/src/serialport/qserialport_win_p.h
@@ -63,6 +63,8 @@ class AbstractOverlappedEventNotifier;
 
 class QSerialPortPrivate : public QSerialPortPrivateData
 {
+    Q_DECLARE_PUBLIC(QSerialPort)
+
 public:
     QSerialPortPrivate(QSerialPort *q);
 
diff --git a/src/serialport/qserialport_wince.cpp b/src/serialport/qserialport_wince.cpp
index 78d2746..2123d17 100644
--- a/src/serialport/qserialport_wince.cpp
+++ b/src/serialport/qserialport_wince.cpp
@@ -164,6 +164,8 @@ QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
 
 bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
+    Q_Q(QSerialPort);
+
     DWORD desiredAccess = 0;
     DWORD eventMask = EV_ERR;
 
@@ -180,12 +182,12 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
                               desiredAccess, 0, NULL, OPEN_EXISTING, 0, NULL);
 
     if (descriptor == INVALID_HANDLE_VALUE) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
     if (!::GetCommState(descriptor, &restoredDcb)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -201,7 +203,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
         return false;
 
     if (!::GetCommTimeouts(descriptor, &restoredCommTimeouts)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
 
@@ -211,7 +213,7 @@ bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
     if (!updateCommTimeouts())
         return false;
 
-    eventNotifier = new CommEventNotifier(eventMask, this, q_ptr);
+    eventNotifier = new CommEventNotifier(eventMask, this, q);
     eventNotifier->start();
 
     detectDefaultSettings();
@@ -354,6 +356,8 @@ bool QSerialPortPrivate::waitForBytesWritten(int msec)
 
 bool QSerialPortPrivate::notifyRead()
 {
+    Q_Q(QSerialPort);
+
     DWORD bytesToRead = (policy == QSerialPort::IgnorePolicy) ? ReadChunkSize : 1;
 
     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
@@ -372,7 +376,7 @@ bool QSerialPortPrivate::notifyRead()
 
     if (!sucessResult) {
         readBuffer.truncate(bytesToRead);
-        q_ptr->setError(QSerialPort::ReadError);
+        q->setError(QSerialPort::ReadError);
         return false;
     }
 
@@ -400,27 +404,29 @@ bool QSerialPortPrivate::notifyRead()
     }
 
     if (readBytes > 0)
-        emit q_ptr->readyRead();
+        emit q->readyRead();
 
     return true;
 }
 
 bool QSerialPortPrivate::notifyWrite(int maxSize)
 {
+    Q_Q(QSerialPort);
+
     int nextSize = qMin(writeBuffer.nextDataBlockSize(), maxSize);
 
     const char *ptr = writeBuffer.readPointer();
 
     DWORD bytesWritten = 0;
     if (!::WriteFile(descriptor, ptr, nextSize, &bytesWritten, NULL)) {
-        q_ptr->setError(QSerialPort::WriteError);
+        q->setError(QSerialPort::WriteError);
         return false;
     }
 
     writeBuffer.free(bytesWritten);
 
     if (bytesWritten > 0)
-        emit q_ptr->bytesWritten(bytesWritten);
+        emit q->bytesWritten(bytesWritten);
 
     return true;
 }
@@ -458,6 +464,8 @@ bool QSerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectFor
 
 bool QSerialPortPrivate::updateDcb()
 {
+    Q_Q(QSerialPort);
+
     QMutexLocker locker(&settingsChangeMutex);
 
     DWORD eventMask = 0;
@@ -470,7 +478,7 @@ bool QSerialPortPrivate::updateDcb()
     // Change parameters
     bool ret = ::SetCommState(descriptor, &currentDcb);
     if (!ret)
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
     // Restore the event mask
     ::SetCommMask(descriptor, eventMask);
 
@@ -479,8 +487,10 @@ bool QSerialPortPrivate::updateDcb()
 
 bool QSerialPortPrivate::updateCommTimeouts()
 {
+    Q_Q(QSerialPort);
+
     if (!::SetCommTimeouts(descriptor, &currentCommTimeouts)) {
-        q_ptr->setError(decodeSystemError());
+        q->setError(decodeSystemError());
         return false;
     }
     return true;