Rename the SerialPort* classes to QSerialPort* including the internals.

Unfortunately, the rename has to happen in a separate commit because of the
limitations of "git":

"git does not track renames of files in history, git only records tree
snapshots. It can try to guess whether a change was a rename, or just unrelated
removal+addition, when asked. You can help this by making the rename in a
different commit from a modification. See man git-log -C and -M"

... so the rename will happen in the next change.

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

40 files changed, 872 insertions, 872 deletions

diff --git a/examples/blockingmaster/dialog.cpp b/examples/blockingmaster/dialog.cpp
index 4003401..c744ee0 100644
--- a/examples/blockingmaster/dialog.cpp
+++ b/examples/blockingmaster/dialog.cpp
@@ -65,7 +65,7 @@ Dialog::Dialog(QWidget *parent)
     , statusLabel(new QLabel(tr("Status: Not running.")))
     , runButton(new QPushButton(tr("Start")))
 {
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts())
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
         serialPortComboBox->addItem(info.portName());
 
     waitResponseSpinBox->setRange(0, 10000);
diff --git a/examples/blockingmaster/masterthread.cpp b/examples/blockingmaster/masterthread.cpp
index 92bf6ac..6cee93b 100644
--- a/examples/blockingmaster/masterthread.cpp
+++ b/examples/blockingmaster/masterthread.cpp
@@ -96,7 +96,7 @@ void MasterThread::run()
     QString currentRequest = request;
     mutex.unlock();
     //! [5] //! [6]
-    SerialPort serial;
+    QSerialPort serial;
 
     while (!quit) {
         //![6] //! [7]
@@ -110,31 +110,31 @@ void MasterThread::run()
                 return;
             }
 
-            if (!serial.setBaudRate(SerialPort::Baud9600)) {
+            if (!serial.setBaudRate(QSerialPort::Baud9600)) {
                 emit error(tr("Can't set baud rate 9600 baud to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setDataBits(SerialPort::Data8)) {
+            if (!serial.setDataBits(QSerialPort::Data8)) {
                 emit error(tr("Can't set 8 data bits to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setParity(SerialPort::NoParity)) {
+            if (!serial.setParity(QSerialPort::NoParity)) {
                 emit error(tr("Can't set no patity to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setStopBits(SerialPort::OneStop)) {
+            if (!serial.setStopBits(QSerialPort::OneStop)) {
                 emit error(tr("Can't set 1 stop bit to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setFlowControl(SerialPort::NoFlowControl)) {
+            if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
                 emit error(tr("Can't set no flow control to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
diff --git a/examples/blockingslave/dialog.cpp b/examples/blockingslave/dialog.cpp
index b5a8118..c4f68a9 100644
--- a/examples/blockingslave/dialog.cpp
+++ b/examples/blockingslave/dialog.cpp
@@ -68,7 +68,7 @@ Dialog::Dialog(QWidget *parent)
     waitRequestSpinBox->setRange(0, 10000);
     waitRequestSpinBox->setValue(10000);
 
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts())
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
         serialPortComboBox->addItem(info.portName());
 
     QGridLayout *mainLayout = new QGridLayout;
diff --git a/examples/blockingslave/slavethread.cpp b/examples/blockingslave/slavethread.cpp
index 1aac918..1242f3c 100644
--- a/examples/blockingslave/slavethread.cpp
+++ b/examples/blockingslave/slavethread.cpp
@@ -92,7 +92,7 @@ void SlaveThread::run()
     QString currentRespone = response;
     mutex.unlock();
 //! [5] //! [6]
-    SerialPort serial;
+    QSerialPort serial;
 
     while (!quit) {
 //![6] //! [7]
@@ -106,31 +106,31 @@ void SlaveThread::run()
                 return;
             }
 
-            if (!serial.setBaudRate(SerialPort::Baud9600)) {
+            if (!serial.setBaudRate(QSerialPort::Baud9600)) {
                 emit error(tr("Can't set baud rate 9600 baud to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setDataBits(SerialPort::Data8)) {
+            if (!serial.setDataBits(QSerialPort::Data8)) {
                 emit error(tr("Can't set 8 data bits to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setParity(SerialPort::NoParity)) {
+            if (!serial.setParity(QSerialPort::NoParity)) {
                 emit error(tr("Can't set no patity to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setStopBits(SerialPort::OneStop)) {
+            if (!serial.setStopBits(QSerialPort::OneStop)) {
                 emit error(tr("Can't set 1 stop bit to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setFlowControl(SerialPort::NoFlowControl)) {
+            if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
                 emit error(tr("Can't set no flow control to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
diff --git a/examples/cenumerator/main.cpp b/examples/cenumerator/main.cpp
index 8d03c98..b8f1ef7 100644
--- a/examples/cenumerator/main.cpp
+++ b/examples/cenumerator/main.cpp
@@ -49,11 +49,11 @@ int main(int argc, char *argv[])
 {
     QCoreApplication a(argc, argv);
     QTextStream out(stdout);
-    QList<SerialPortInfo> serialPortInfoList = SerialPortInfo::availablePorts();
+    QList<QSerialPortInfo> serialPortInfoList = QSerialPortInfo::availablePorts();
 
     out << QObject::tr("Total number of ports available: ") << serialPortInfoList.count() << endl;
 
-    foreach (const SerialPortInfo &serialPortInfo, serialPortInfoList) {
+    foreach (const QSerialPortInfo &serialPortInfo, serialPortInfoList) {
         out << endl
             << QObject::tr("Port: ") << serialPortInfo.portName() << endl
             << QObject::tr("Location: ") << serialPortInfo.systemLocation() << endl
diff --git a/examples/doc/blockingmaster.qdoc b/examples/doc/blockingmaster.qdoc
index 4cafa40..c83d3b8 100644
--- a/examples/doc/blockingmaster.qdoc
+++ b/examples/doc/blockingmaster.qdoc
@@ -31,23 +31,23 @@
     \example examples/blockingmaster
 
     The Blocking Master example shows how to create a application for a
-    serial interface using SerialPort's synchronous API in a non-GUI thread.
+    serial interface using QSerialPort's synchronous API in a non-GUI thread.
 
     \image blockingmaster-example.png Screenshot of the Blocking Master example
 
-    SerialPort supports two general programming approaches:
+    QSerialPort supports two general programming approaches:
 
     \list
 
     \o \i{The asynchronous (non-blocking) approach.} Operations are scheduled
-    and performed when the control returns to Qt's event loop. SerialPort emits
-    a signal when the operation is finished. For example, SerialPort::write()
-    returns immediately. When the data is sent to the serial port, SerialPort
-    emits \l{SerialPort::bytesWritten()}{bytesWritten()}.
+    and performed when the control returns to Qt's event loop. QSerialPort emits
+    a signal when the operation is finished. For example, QSerialPort::write()
+    returns immediately. When the data is sent to the serial port, QSerialPort
+    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
 
     \o \i{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    SerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
@@ -107,7 +107,7 @@
     and timeout or request data of another. And as you might have guessed,
     MasterThread can only handle one request at a time.
 
-    The SerialPort object we construct on stack into run() function before loop
+    The QSerialPort object we construct on stack into run() function before loop
     enter:
 
     \snippet examples/blockingmaster/masterthread.cpp 6
diff --git a/examples/doc/blockingslave.qdoc b/examples/doc/blockingslave.qdoc
index 41bb2b1..f08fa81 100644
--- a/examples/doc/blockingslave.qdoc
+++ b/examples/doc/blockingslave.qdoc
@@ -31,23 +31,23 @@
     \example examples/blockingslave
 
     The Blocking Slave example shows how to create a application for a
-    serial interface using SerialPort's synchronous API in a non-GUI thread.
+    serial interface using QSerialPort's synchronous API in a non-GUI thread.
 
     \image blockingslave-example.png Screenshot of the Blocking Slave example
 
-    SerialPort supports two general programming approaches:
+    QSerialPort supports two general programming approaches:
 
     \list
 
     \o \i{The asynchronous (non-blocking) approach.} Operations are scheduled
-    and performed when the control returns to Qt's event loop. SerialPort emits
-    a signal when the operation is finished. For example, SerialPort::write()
-    returns immediately. When the data is sent to the serial port, SerialPort
-    emits \l{SerialPort::bytesWritten()}{bytesWritten()}.
+    and performed when the control returns to Qt's event loop. QSerialPort emits
+    a signal when the operation is finished. For example, QSerialPort::write()
+    returns immediately. When the data is sent to the serial port, QSerialPort
+    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
 
     \o \i{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    SerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
@@ -110,7 +110,7 @@
     call and timeout or response data of another. And as you might have guessed,
     SlaveThread can only handle one startup at a time.
 
-    The SerialPort object we construct on stack into run() function before loop
+    The QSerialPort object we construct on stack into run() function before loop
     enter:
 
     \snippet examples/blockingslave/slavethread.cpp 6
diff --git a/examples/doc/cenumerator.qdoc b/examples/doc/cenumerator.qdoc
index 1751f47..a894038 100644
--- a/examples/doc/cenumerator.qdoc
+++ b/examples/doc/cenumerator.qdoc
@@ -31,15 +31,15 @@
     \example examples/cenumerator
 
     The Command Line Enumerator example shows how to use the class
-    SerialPortInfo for getting information about serial devices that are present
+    QSerialPortInfo for getting information about serial devices that are present
     in the system.
 
     \image cenumerator-example.png Screenshot of the Command Line Enumerator
     example
 
     This command line example displays information about serial ports in a
-    console, provided by the class SerialPortInfo.
+    console, provided by the class QSerialPortInfo.
 
     For getting information about the available ports, use the static method
-    \l{SerialPortInfo::availablePorts()}{availablePorts()}.
+    \l{QSerialPortInfo::availablePorts()}{availablePorts()}.
 */
diff --git a/examples/doc/enumerator.qdoc b/examples/doc/enumerator.qdoc
index 4c42e55..790d2fb 100644
--- a/examples/doc/enumerator.qdoc
+++ b/examples/doc/enumerator.qdoc
@@ -30,14 +30,14 @@
     \title Enumerator example
     \example examples/enumerator
 
-    The Enumerator example shows how to use the class SerialPortInfo for
+    The Enumerator example shows how to use the class QSerialPortInfo for
     getting information about serial devices that are present in the system.
 
     \image enumerator-example.png Screenshot of the Enumerator example
 
     This GUI example displays information about serial ports in a widget,
-    provided by the class SerialPortInfo.
+    provided by the class QSerialPortInfo.
 
     For getting information about the available ports, use the static method
-    \l{SerialPortInfo::availablePorts()}{availablePorts()}.
+    \l{QSerialPortInfo::availablePorts()}{availablePorts()}.
 */
diff --git a/examples/doc/terminal.qdoc b/examples/doc/terminal.qdoc
index f87be68..090b957 100644
--- a/examples/doc/terminal.qdoc
+++ b/examples/doc/terminal.qdoc
@@ -31,28 +31,28 @@
     \example examples/terminal
 
     The Terminal example shows how to create a terminal for a simple serial
-    interface by using SerialPort.
+    interface by using Qt Serial Port.
 
     \image terminal-example.png Screenshot of the Terminal example
 
-    This example shows the main features of the SerialPort class, like
+    This example shows the main features of the QSerialPort class, like
     configuration, I/O implementation and so forth. Also, the class
-    SerialPortInfo is invoked to display information about the serial ports
+    QSerialPortInfo is invoked to display information about the serial ports
     available in the system.
 
-    SerialPort supports two general programming approaches:
+    QSerialPort supports two general programming approaches:
 
     \list
 
     \o \i{The asynchronous (non-blocking) approach.} Operations are scheduled
-    and performed when the control returns to Qt's event loop. SerialPort emits
-    a signal when the operation is finished. For example, SerialPort::write()
-    returns immediately. When the data is sent to the serial port, SerialPort
-    emits \l{SerialPort::bytesWritten()}{bytesWritten()}.
+    and performed when the control returns to Qt's event loop. QSerialPort emits
+    a signal when the operation is finished. For example, QSerialPort::write()
+    returns immediately. When the data is sent to the serial port, QSerialPort
+    emits \l{QSerialPort::bytesWritten()}{bytesWritten()}.
 
     \o \i{The synchronous (blocking) approach.} In non-GUI and multithreaded
     applications, the \c waitFor...() functions can be called (i.e.
-    SerialPort::waitReadyRead()) to suspend the calling thread until the
+    QSerialPort::waitReadyRead()) to suspend the calling thread until the
     operation has completed.
 
     \endlist
@@ -88,8 +88,8 @@
     \dots
     \snippet examples/terminal/mainwindow.cpp 1
 
-    The only SerialPort signal invoked in this example is
-    SerialPort::readyRead(), which shows that new data has been received and
+    The only QSerialPort signal invoked in this example is
+    QSerialPort::readyRead(), which shows that new data has been received and
     hence available:
 
     \dots
diff --git a/examples/enumerator/main.cpp b/examples/enumerator/main.cpp
index 6635990..c188d60 100644
--- a/examples/enumerator/main.cpp
+++ b/examples/enumerator/main.cpp
@@ -56,7 +56,7 @@ int main(int argc, char *argv[])
     w.setWindowTitle(QObject::tr("Info about all available serial ports."));
     QVBoxLayout *layout = new QVBoxLayout;
 
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts()) {
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts()) {
         QString s(QObject::tr("Port: %1\n"
                               "Location: %2\n"
                               "Description: %3\n"
diff --git a/examples/master/dialog.cpp b/examples/master/dialog.cpp
index 4df45f4..36c4a8f 100644
--- a/examples/master/dialog.cpp
+++ b/examples/master/dialog.cpp
@@ -65,7 +65,7 @@ Dialog::Dialog(QWidget *parent)
     , statusLabel(new QLabel(tr("Status: Not running.")))
     , runButton(new QPushButton(tr("Start")))
 {
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts())
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
         serialPortComboBox->addItem(info.portName());
 
     waitResponseSpinBox->setRange(0, 10000);
@@ -108,31 +108,31 @@ void Dialog::sendRequest()
             return;
         }
 
-        if (!serial.setBaudRate(SerialPort::Baud9600)) {
+        if (!serial.setBaudRate(QSerialPort::Baud9600)) {
             processError(tr("Can't set rate 9600 baud to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setDataBits(SerialPort::Data8)) {
+        if (!serial.setDataBits(QSerialPort::Data8)) {
             processError(tr("Can't set 8 data bits to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setParity(SerialPort::NoParity)) {
+        if (!serial.setParity(QSerialPort::NoParity)) {
             processError(tr("Can't set no patity to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setStopBits(SerialPort::OneStop)) {
+        if (!serial.setStopBits(QSerialPort::OneStop)) {
             processError(tr("Can't set 1 stop bit to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setFlowControl(SerialPort::NoFlowControl)) {
+        if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
             processError(tr("Can't set no flow control to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
diff --git a/examples/master/dialog.h b/examples/master/dialog.h
index 0dfa271..e2100ac 100644
--- a/examples/master/dialog.h
+++ b/examples/master/dialog.h
@@ -83,7 +83,7 @@ private:
     QLabel *statusLabel;
     QPushButton *runButton;
 
-    SerialPort serial;
+    QSerialPort serial;
     QByteArray response;
     QTimer timer;
 };
diff --git a/examples/slave/dialog.cpp b/examples/slave/dialog.cpp
index 3c4c59a..922fb61 100644
--- a/examples/slave/dialog.cpp
+++ b/examples/slave/dialog.cpp
@@ -68,7 +68,7 @@ Dialog::Dialog(QWidget *parent)
     waitRequestSpinBox->setRange(0, 10000);
     waitRequestSpinBox->setValue(20);
 
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts())
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts())
         serialPortComboBox->addItem(info.portName());
 
     QGridLayout *mainLayout = new QGridLayout;
@@ -115,31 +115,31 @@ void Dialog::startSlave()
             return;
         }
 
-        if (!serial.setBaudRate(SerialPort::Baud9600)) {
+        if (!serial.setBaudRate(QSerialPort::Baud9600)) {
             processError(tr("Can't set baud rate 9600 baud to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setDataBits(SerialPort::Data8)) {
+        if (!serial.setDataBits(QSerialPort::Data8)) {
             processError(tr("Can't set 8 data bits to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setParity(SerialPort::NoParity)) {
+        if (!serial.setParity(QSerialPort::NoParity)) {
             processError(tr("Can't set no patity to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setStopBits(SerialPort::OneStop)) {
+        if (!serial.setStopBits(QSerialPort::OneStop)) {
             processError(tr("Can't set 1 stop bit to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
         }
 
-        if (!serial.setFlowControl(SerialPort::NoFlowControl)) {
+        if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
             processError(tr("Can't set no flow control to port %1, error code %2")
                          .arg(serial.portName()).arg(serial.error()));
             return;
diff --git a/examples/slave/dialog.h b/examples/slave/dialog.h
index 995ae4c..f876298 100644
--- a/examples/slave/dialog.h
+++ b/examples/slave/dialog.h
@@ -83,7 +83,7 @@ private:
     QLabel *statusLabel;
     QPushButton *runButton;
 
-    SerialPort serial;
+    QSerialPort serial;
     QByteArray request;
     QTimer timer;
 };
diff --git a/examples/slave/slavethread.cpp b/examples/slave/slavethread.cpp
index e3ed22a..83da104 100644
--- a/examples/slave/slavethread.cpp
+++ b/examples/slave/slavethread.cpp
@@ -86,7 +86,7 @@ void SlaveThread::run()
     QString currentRespone = response;
     mutex.unlock();
 
-    SerialPort serial;
+    QSerialPort serial;
 
     while (!quit) {
 
@@ -100,31 +100,31 @@ void SlaveThread::run()
                 return;
             }
 
-            if (!serial.setBaudRate(SerialPort::Baud9600)) {
+            if (!serial.setBaudRate(QSerialPort::Baud9600)) {
                 emit error(tr("Can't set baud rate 9600 baud to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setDataBits(SerialPort::Data8)) {
+            if (!serial.setDataBits(QSerialPort::Data8)) {
                 emit error(tr("Can't set 8 data bits to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setParity(SerialPort::NoParity)) {
+            if (!serial.setParity(QSerialPort::NoParity)) {
                 emit error(tr("Can't set no patity to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setStopBits(SerialPort::OneStop)) {
+            if (!serial.setStopBits(QSerialPort::OneStop)) {
                 emit error(tr("Can't set 1 stop bit to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
             }
 
-            if (!serial.setFlowControl(SerialPort::NoFlowControl)) {
+            if (!serial.setFlowControl(QSerialPort::NoFlowControl)) {
                 emit error(tr("Can't set no flow control to port %1, error code %2")
                            .arg(portName).arg(serial.error()));
                 return;
diff --git a/examples/terminal/mainwindow.cpp b/examples/terminal/mainwindow.cpp
index 079b541..dffb4f8 100644
--- a/examples/terminal/mainwindow.cpp
+++ b/examples/terminal/mainwindow.cpp
@@ -59,7 +59,7 @@ MainWindow::MainWindow(QWidget *parent) :
     console->setEnabled(false);
     setCentralWidget(console);
 //! [1]
-    serial = new SerialPort(this);
+    serial = new QSerialPort(this);
 //! [1]
     settings = new SettingsDialog;
 
diff --git a/examples/terminal/mainwindow.h b/examples/terminal/mainwindow.h
index a3dfbeb..272bcce 100644
--- a/examples/terminal/mainwindow.h
+++ b/examples/terminal/mainwindow.h
@@ -57,7 +57,7 @@ class Console;
 class SettingsDialog;
 
 QT_BEGIN_NAMESPACE_SERIALPORT
-class SerialPort;
+class QSerialPort;
 QT_END_NAMESPACE_SERIALPORT
 
 QT_USE_NAMESPACE_SERIALPORT
@@ -84,7 +84,7 @@ private:
     Ui::MainWindow *ui;
     Console *console;
     SettingsDialog *settings;
-    SerialPort *serial;
+    QSerialPort *serial;
 };
 
 #endif // MAINWINDOW_H
diff --git a/examples/terminal/settingsdialog.cpp b/examples/terminal/settingsdialog.cpp
index 54a48c9..5d13cdf 100644
--- a/examples/terminal/settingsdialog.cpp
+++ b/examples/terminal/settingsdialog.cpp
@@ -112,43 +112,43 @@ void SettingsDialog::fillPortsParameters()
 {
     // fill baud rate (is not the entire list of available values,
     // desired values??, add your independently)
-    ui->baudRateBox->addItem(QLatin1String("9600"), SerialPort::Baud9600);
-    ui->baudRateBox->addItem(QLatin1String("19200"), SerialPort::Baud19200);
-    ui->baudRateBox->addItem(QLatin1String("38400"), SerialPort::Baud38400);
-    ui->baudRateBox->addItem(QLatin1String("115200"), SerialPort::Baud115200);
+    ui->baudRateBox->addItem(QLatin1String("9600"), QSerialPort::Baud9600);
+    ui->baudRateBox->addItem(QLatin1String("19200"), QSerialPort::Baud19200);
+    ui->baudRateBox->addItem(QLatin1String("38400"), QSerialPort::Baud38400);
+    ui->baudRateBox->addItem(QLatin1String("115200"), QSerialPort::Baud115200);
     ui->baudRateBox->addItem(QLatin1String("Custom"));
 
     // fill data bits
-    ui->dataBitsBox->addItem(QLatin1String("5"), SerialPort::Data5);
-    ui->dataBitsBox->addItem(QLatin1String("6"), SerialPort::Data6);
-    ui->dataBitsBox->addItem(QLatin1String("7"), SerialPort::Data7);
-    ui->dataBitsBox->addItem(QLatin1String("8"), SerialPort::Data8);
+    ui->dataBitsBox->addItem(QLatin1String("5"), QSerialPort::Data5);
+    ui->dataBitsBox->addItem(QLatin1String("6"), QSerialPort::Data6);
+    ui->dataBitsBox->addItem(QLatin1String("7"), QSerialPort::Data7);
+    ui->dataBitsBox->addItem(QLatin1String("8"), QSerialPort::Data8);
     ui->dataBitsBox->setCurrentIndex(3);
 
     // fill parity
-    ui->parityBox->addItem(QLatin1String("None"), SerialPort::NoParity);
-    ui->parityBox->addItem(QLatin1String("Even"), SerialPort::EvenParity);
-    ui->parityBox->addItem(QLatin1String("Odd"), SerialPort::OddParity);
-    ui->parityBox->addItem(QLatin1String("Mark"), SerialPort::MarkParity);
-    ui->parityBox->addItem(QLatin1String("Space"), SerialPort::SpaceParity);
+    ui->parityBox->addItem(QLatin1String("None"), QSerialPort::NoParity);
+    ui->parityBox->addItem(QLatin1String("Even"), QSerialPort::EvenParity);
+    ui->parityBox->addItem(QLatin1String("Odd"), QSerialPort::OddParity);
+    ui->parityBox->addItem(QLatin1String("Mark"), QSerialPort::MarkParity);
+    ui->parityBox->addItem(QLatin1String("Space"), QSerialPort::SpaceParity);
 
     // fill stop bits
-    ui->stopBitsBox->addItem(QLatin1String("1"), SerialPort::OneStop);
+    ui->stopBitsBox->addItem(QLatin1String("1"), QSerialPort::OneStop);
 #ifdef Q_OS_WIN
-    ui->stopBitsBox->addItem(QLatin1String("1.5"), SerialPort::OneAndHalfStop);
+    ui->stopBitsBox->addItem(QLatin1String("1.5"), QSerialPort::OneAndHalfStop);
 #endif
-    ui->stopBitsBox->addItem(QLatin1String("2"), SerialPort::TwoStop);
+    ui->stopBitsBox->addItem(QLatin1String("2"), QSerialPort::TwoStop);
 
     // fill flow control
-    ui->flowControlBox->addItem(QLatin1String("None"), SerialPort::NoFlowControl);
-    ui->flowControlBox->addItem(QLatin1String("RTS/CTS"), SerialPort::HardwareControl);
-    ui->flowControlBox->addItem(QLatin1String("XON/XOFF"), SerialPort::SoftwareControl);
+    ui->flowControlBox->addItem(QLatin1String("None"), QSerialPort::NoFlowControl);
+    ui->flowControlBox->addItem(QLatin1String("RTS/CTS"), QSerialPort::HardwareControl);
+    ui->flowControlBox->addItem(QLatin1String("XON/XOFF"), QSerialPort::SoftwareControl);
 }
 
 void SettingsDialog::fillPortsInfo()
 {
     ui->portsBox->clear();
-    foreach (const SerialPortInfo &info, SerialPortInfo::availablePorts()) {
+    foreach (const QSerialPortInfo &info, QSerialPortInfo::availablePorts()) {
         QStringList list;
         list << info.portName() << info.description()
              << info.manufacturer() << info.systemLocation()
@@ -168,28 +168,28 @@ void SettingsDialog::updateSettings()
         currentSettings.baudRate = ui->baudRateBox->currentText().toInt();
     } else {
         // standard baud rate
-        currentSettings.baudRate = static_cast<SerialPort::BaudRate>(
+        currentSettings.baudRate = static_cast<QSerialPort::BaudRate>(
                     ui->baudRateBox->itemData(ui->baudRateBox->currentIndex()).toInt());
     }
     currentSettings.stringBaudRate = QString::number(currentSettings.baudRate);
 
     // Data bits
-    currentSettings.dataBits = static_cast<SerialPort::DataBits>(
+    currentSettings.dataBits = static_cast<QSerialPort::DataBits>(
                 ui->dataBitsBox->itemData(ui->dataBitsBox->currentIndex()).toInt());
     currentSettings.stringDataBits = ui->dataBitsBox->currentText();
 
     // Parity
-    currentSettings.parity = static_cast<SerialPort::Parity>(
+    currentSettings.parity = static_cast<QSerialPort::Parity>(
                 ui->parityBox->itemData(ui->parityBox->currentIndex()).toInt());
     currentSettings.stringParity = ui->parityBox->currentText();
 
     // Stop bits
-    currentSettings.stopBits = static_cast<SerialPort::StopBits>(
+    currentSettings.stopBits = static_cast<QSerialPort::StopBits>(
                 ui->stopBitsBox->itemData(ui->stopBitsBox->currentIndex()).toInt());
     currentSettings.stringStopBits = ui->stopBitsBox->currentText();
 
     // Flow control
-    currentSettings.flowControl = static_cast<SerialPort::FlowControl>(
+    currentSettings.flowControl = static_cast<QSerialPort::FlowControl>(
                 ui->flowControlBox->itemData(ui->flowControlBox->currentIndex()).toInt());
     currentSettings.stringFlowControl = ui->flowControlBox->currentText();
 }
diff --git a/examples/terminal/settingsdialog.h b/examples/terminal/settingsdialog.h
index ef3ab25..bfdf9f3 100644
--- a/examples/terminal/settingsdialog.h
+++ b/examples/terminal/settingsdialog.h
@@ -63,13 +63,13 @@ public:
         QString name;
         qint32 baudRate;
         QString stringBaudRate;
-        SerialPort::DataBits dataBits;
+        QSerialPort::DataBits dataBits;
         QString stringDataBits;
-        SerialPort::Parity parity;
+        QSerialPort::Parity parity;
         QString stringParity;
-        SerialPort::StopBits stopBits;
+        QSerialPort::StopBits stopBits;
         QString stringStopBits;
-        SerialPort::FlowControl flowControl;
+        QSerialPort::FlowControl flowControl;
         QString stringFlowControl;
     };
 
diff --git a/src/serialport/serialport.cpp b/src/serialport/serialport.cpp
index 4a2da35..4e17139 100644
--- a/src/serialport/serialport.cpp
+++ b/src/serialport/serialport.cpp
@@ -61,24 +61,24 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-SerialPortPrivateData::SerialPortPrivateData(SerialPort *q)
+QSerialPortPrivateData::QSerialPortPrivateData(QSerialPort *q)
     : readBufferMaxSize(0)
     , readBuffer(SERIALPORT_BUFFERSIZE)
     , writeBuffer(SERIALPORT_BUFFERSIZE)
-    , portError(SerialPort::NoError)
+    , portError(QSerialPort::NoError)
     , inputBaudRate(0)
     , outputBaudRate(0)
-    , dataBits(SerialPort::UnknownDataBits)
-    , parity(SerialPort::UnknownParity)
-    , stopBits(SerialPort::UnknownStopBits)
-    , flow(SerialPort::UnknownFlowControl)
-    , policy(SerialPort::IgnorePolicy)
+    , dataBits(QSerialPort::UnknownDataBits)
+    , parity(QSerialPort::UnknownParity)
+    , stopBits(QSerialPort::UnknownStopBits)
+    , flow(QSerialPort::UnknownFlowControl)
+    , policy(QSerialPort::IgnorePolicy)
     , restoreSettingsOnClose(true)
     , q_ptr(q)
 {
 }
 
-int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
+int QSerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 {
     if (msecs == -1)
         return msecs;
@@ -87,9 +87,9 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 }
 
 /*!
-    \class SerialPort
+    \class QSerialPort
 
-    \brief The SerialPort class provides functions to access
+    \brief The QSerialPort class provides functions to access
     serial ports.
 
     \reentrant
@@ -100,7 +100,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     This class resembles the functionality and behavior of the QAbstractSocket
     class in many aspects, for instance the I/O operations, the implementation
     of the wait methods, the internal architecture and so forth. Certain
-    SerialPort method implementations were taken directly from QAbstractSocket
+    QSerialPort method implementations were taken directly from QAbstractSocket
     with only minor changes.
 
     The features of the implementation and the conduct of the class are
@@ -119,17 +119,17 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     of RS-232 lines was changed.
     \endlist
 
-    To get started with the SerialPort class, first create an object of
+    To get started with the QSerialPort class, first create an object of
     that.
 
     Then, call the setPort() method in order to assign the object with the name
     of the desired serial port (which has to be present in the system).
     The name has to follow a certain format, which is platform dependent.
 
-    The helper class SerialPortInfo allows the enumeration of all the serial
+    The helper class QSerialPortInfo allows the enumeration of all the serial
     ports in the system. This is useful to obtain the correct serial port name.
 
-    The SerialPortInfo class can also be used as an input parameter for the
+    The QSerialPortInfo class can also be used as an input parameter for the
     setPort() method (to retrieve the currently assigned name, use the
     portName() method).
 
@@ -139,7 +139,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     Note: The serial port is always opened with exclusive access
     (i.e. no other process or thread can access an already opened serial port).
 
-    Having successfully opened, the SerialPort determines its current
+    Having successfully opened, the QSerialPort determines its current
     configuration and initializes itself to that. To access the current
     configuration use the baudRate(), dataBits(), parity(), stopBits(), and
     flowControl() methods.
@@ -151,7 +151,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 
     Read or write the data by calling read() or write(). Alternatively the
     readLine() and readAll() convenience methods can also be invoked. The
-    SerialPort class also inherits the getChar(), putChar(), and ungetChar()
+    QSerialPort class also inherits the getChar(), putChar(), and ungetChar()
     methods from the QIODevice class. Those methods work on single bytes. The
     bytesWritten() signal is emitted when data has been written to the serial
     port. Note that, Qt does not limit the write buffer size, which can be
@@ -164,7 +164,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 
     If not all the data is read at once, the remaining data will
     still be available later. Any new incoming data will be
-    appended to the SerialPort's internal read buffer. In order to limit the
+    appended to the QSerialPort's internal read buffer. In order to limit the
     size of the read buffer, call setReadBufferSize().
 
     The status of the control lines is determined with the dtr(), rts(), and
@@ -172,10 +172,10 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     setRts() methods.
 
     To close the serial port, call the close() method. After all the pending data
-    has been written to the serial port, the SerialPort class actually closes
+    has been written to the serial port, the QSerialPort class actually closes
     the descriptor.
 
-    SerialPort provides a set of functions that suspend the calling
+    QSerialPort provides a set of functions that suspend the calling
     thread until certain signals are emitted. These functions can be
     used to implement blocking serial ports:
 
@@ -219,16 +219,16 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
     The use of blocking functions is discouraged together with signals. One of
     the two possibilities should be used.
 
-    The SerialPort class can be used with QTextStream and QDataStream's stream
+    The QSerialPort class can be used with QTextStream and QDataStream's stream
     operators (operator<<() and operator>>()). There is one issue to be aware
     of, though: make sure that enough data is available before attempting to
     read by using the operator>>() overloaded operator.
 
-    \sa SerialPortInfo
+    \sa QSerialPortInfo
 */
 
 /*!
-    \enum SerialPort::Direction
+    \enum QSerialPort::Direction
 
     This enum describes the possible directions of the data transmission.
     Note: This enumeration is used for setting the baud rate of the device
@@ -240,7 +240,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::BaudRate
+    \enum QSerialPort::BaudRate
 
     This enum describes the baud rate which the communication device operates
     with. Note: only the most common standard baud rates are listed in this
@@ -260,7 +260,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::DataBits
+    \enum QSerialPort::DataBits
 
     This enum describes the number of data bits used.
 
@@ -274,7 +274,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::Parity
+    \enum QSerialPort::Parity
 
     This enum describes the parity scheme used.
 
@@ -289,7 +289,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::StopBits
+    \enum QSerialPort::StopBits
 
     This enum describes the number of stop bits used.
 
@@ -302,7 +302,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::FlowControl
+    \enum QSerialPort::FlowControl
 
     This enum describes the flow control used.
 
@@ -315,7 +315,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::Line
+    \enum QSerialPort::Line
 
     This enum describes the possible RS-232 pinout signals.
 
@@ -333,7 +333,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::DataErrorPolicy
+    \enum QSerialPort::DataErrorPolicy
 
     This enum describes the policies for the received symbols
     while parity errors were detected.
@@ -348,7 +348,7 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 */
 
 /*!
-    \enum SerialPort::PortError
+    \enum QSerialPort::PortError
 
     This enum describes the errors that may be returned by the error()
     method.
@@ -380,9 +380,9 @@ int SerialPortPrivateData::timeoutValue(int msecs, int elapsed)
 /*!
     Constructs a new serial port object with the given \a parent.
 */
-SerialPort::SerialPort(QObject *parent)
+QSerialPort::QSerialPort(QObject *parent)
     : QIODevice(parent)
-    , d_ptr(new SerialPortPrivate(this))
+    , d_ptr(new QSerialPortPrivate(this))
 {}
 
 /*!
@@ -391,9 +391,9 @@ SerialPort::SerialPort(QObject *parent)
 
     The name should have a specific format; see the setPort() method.
 */
-SerialPort::SerialPort(const QString &name, QObject *parent)
+QSerialPort::QSerialPort(const QString &name, QObject *parent)
     : QIODevice(parent)
-    , d_ptr(new SerialPortPrivate(this))
+    , d_ptr(new QSerialPortPrivate(this))
 {
     setPort(name);
 }
@@ -403,9 +403,9 @@ SerialPort::SerialPort(const QString &name, QObject *parent)
     to represent the serial port with the specified a helper
     class \a info.
 */
-SerialPort::SerialPort(const SerialPortInfo &info, QObject *parent)
+QSerialPort::QSerialPort(const QSerialPortInfo &info, QObject *parent)
     : QIODevice(parent)
-    , d_ptr(new SerialPortPrivate(this))
+    , d_ptr(new QSerialPortPrivate(this))
 {
     setPort(info);
 }
@@ -413,7 +413,7 @@ SerialPort::SerialPort(const SerialPortInfo &info, QObject *parent)
 /*!
     Closes the serial port, if neccessary, and then destroys object.
 */
-SerialPort::~SerialPort()
+QSerialPort::~QSerialPort()
 {
     /**/
     close();
@@ -426,27 +426,27 @@ SerialPort::~SerialPort()
     postfixed). As a result, this name will be automatically written
     and converted into an internal variable as system location.
 
-    \sa portName(), SerialPortInfo
+    \sa portName(), QSerialPortInfo
 */
-void SerialPort::setPort(const QString &name)
+void QSerialPort::setPort(const QString &name)
 {
-    Q_D(SerialPort);
-    d->systemLocation = SerialPortPrivate::portNameToSystemLocation(name);
+    Q_D(QSerialPort);
+    d->systemLocation = QSerialPortPrivate::portNameToSystemLocation(name);
 }
 
 /*!
     Sets the port stored in the serial port info instance \a info.
 
-    \sa portName(), SerialPortInfo
+    \sa portName(), QSerialPortInfo
 */
-void SerialPort::setPort(const SerialPortInfo &info)
+void QSerialPort::setPort(const QSerialPortInfo &info)
 {
-    Q_D(SerialPort);
-    d->systemLocation = SerialPortPrivate::portNameToSystemLocation(info.systemLocation());
+    Q_D(QSerialPort);
+    d->systemLocation = QSerialPortPrivate::portNameToSystemLocation(info.systemLocation());
 }
 
 /*!
-    Returns the name set by setPort() or to the SerialPort constructors.
+    Returns the name set by setPort() or to the QSerialPort constructors.
     This name is short, i.e. it extract and convert out from the internal
     variable system location of the device. Conversion algorithm is
     platform specific:
@@ -479,12 +479,12 @@ void SerialPort::setPort(const SerialPortInfo &info)
         \o The same as for GNU/Linux.
     \endtable
 
-    \sa setPort(), SerialPortInfo::portName()
+    \sa setPort(), QSerialPortInfo::portName()
 */
-QString SerialPort::portName() const
+QString QSerialPort::portName() const
 {
-    Q_D(const SerialPort);
-    return SerialPortPrivate::portNameFromSystemLocation(d->systemLocation);
+    Q_D(const QSerialPort);
+    return QSerialPortPrivate::portNameFromSystemLocation(d->systemLocation);
 }
 
 /*! \reimp
@@ -498,19 +498,19 @@ QString SerialPort::portName() const
 
     \sa QIODevice::OpenMode, setPort()
 */
-bool SerialPort::open(OpenMode mode)
+bool QSerialPort::open(OpenMode mode)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
 
     if (isOpen()) {
-        d->portError = SerialPort::DeviceAlreadyOpenedError;
+        d->portError = QSerialPort::DeviceAlreadyOpenedError;
         return false;
     }
 
     // Define while not supported modes.
     static const OpenMode unsupportedModes = Append | Truncate | Text | Unbuffered;
     if ((mode & unsupportedModes) || mode == NotOpen) {
-        d->portError = SerialPort::UnsupportedPortOperationError;
+        d->portError = QSerialPort::UnsupportedPortOperationError;
         return false;
     }
 
@@ -523,16 +523,16 @@ bool SerialPort::open(OpenMode mode)
 }
 
 /*! \reimp
-    Calls SerialPort::flush() and closes the serial port.
+    Calls QSerialPort::flush() and closes the serial port.
     Errors from flush are ignored.
 
     \sa QIODevice::close()
 */
-void SerialPort::close()
+void QSerialPort::close()
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (!isOpen()) {
-        d->portError = SerialPort::DeviceIsNotOpenedError;
+        d->portError = QSerialPort::DeviceIsNotOpenedError;
         return;
     }
 
@@ -541,19 +541,19 @@ void SerialPort::close()
 }
 
 /*!
-    \property SerialPort::restoreSettingsOnClose
+    \property QSerialPort::restoreSettingsOnClose
     \brief the flag which allows to restore the previous settings while closing
     the serial port.
 
     If this flag is true, the settings will be restored; otherwise not.
-    The default state of the SerialPort class is configured to restore the
+    The default state of the QSerialPort class is configured to restore the
     settings.
 
     \sa restoreSettingsOnClose()
 */
-void SerialPort::setRestoreSettingsOnClose(bool restore)
+void QSerialPort::setRestoreSettingsOnClose(bool restore)
 {
-    Q_D( SerialPort);
+    Q_D(QSerialPort);
 
     d->restoreSettingsOnClose = restore;
     emit restoreSettingsOnCloseChanged(d->restoreSettingsOnClose);
@@ -561,35 +561,35 @@ void SerialPort::setRestoreSettingsOnClose(bool restore)
 
 /*!
     Returns the current status of the restore flag settings on
-    closing the port. The default SerialPort is configured to
+    closing the port. The default QSerialPort is configured to
     restore the settings.
 
     \sa setRestoreSettingsOnClose()
 */
-bool SerialPort::restoreSettingsOnClose() const
+bool QSerialPort::restoreSettingsOnClose() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->restoreSettingsOnClose;
 }
 
 /*!
-    \fn void SerialPort::restoreSettingsOnCloseChanged(bool restore)
+    \fn void QSerialPort::restoreSettingsOnCloseChanged(bool restore)
 
     This signal is emitted after the flag which allows to restore the
     previous settings while closing the serial port has been changed. The new
     flag which allows to restore the previous settings while closing the serial
     port is passed as \restore.
 
-    \sa SerialPort::restoreSettingsOnClose
+    \sa QSerialPort::restoreSettingsOnClose
 */
 
 /*!
-    \property SerialPort::baudRate
+    \property QSerialPort::baudRate
     \brief the data baud rate for the desired direction
 
     If the setting is successful, returns true; otherwise returns false and sets
     an error code which can be obtained by calling error(). To set the baud
-    rate, use the enumeration SerialPort::Rate or any positive qint32 value.
+    rate, use the enumeration QSerialPort::Rate or any positive qint32 value.
 
     \warning Only the AllDirections flag is support for setting this property on
     Windows, Windows CE, and Symbian.
@@ -597,13 +597,13 @@ bool SerialPort::restoreSettingsOnClose() const
     \warning Returns equal baud rate in any direction on Windows, Windows CE, and
     Symbian.
 */
-bool SerialPort::setBaudRate(qint32 baudRate, Directions dir)
+bool QSerialPort::setBaudRate(qint32 baudRate, Directions dir)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (d->setBaudRate(baudRate, dir)) {
-        if (dir & SerialPort::Input)
+        if (dir & QSerialPort::Input)
             d->inputBaudRate = baudRate;
-        if (dir & SerialPort::Output)
+        if (dir & QSerialPort::Output)
             d->outputBaudRate = baudRate;
         emit baudRateChanged(baudRate, dir);
         return true;
@@ -611,34 +611,34 @@ bool SerialPort::setBaudRate(qint32 baudRate, Directions dir)
     return false;
 }
 
-qint32 SerialPort::baudRate(Directions dir) const
+qint32 QSerialPort::baudRate(Directions dir) const
 {
-    Q_D(const SerialPort);
-    if (dir == SerialPort::AllDirections)
+    Q_D(const QSerialPort);
+    if (dir == QSerialPort::AllDirections)
         return d->inputBaudRate == d->outputBaudRate ?
-                    d->inputBaudRate : SerialPort::UnknownBaud;
-    return dir & SerialPort::Input ? d->inputBaudRate : d->outputBaudRate;
+                    d->inputBaudRate : QSerialPort::UnknownBaud;
+    return dir & QSerialPort::Input ? d->inputBaudRate : d->outputBaudRate;
 }
 
 /*!
-    \fn void SerialPort::baudRateChanged(qint32 baudRate, Directions dir)
+    \fn void QSerialPort::baudRateChanged(qint32 baudRate, Directions dir)
 
     This signal is emitted after the baud rate has been changed. The new baud
     rate is passed as \a baudRate and directions as \a dir.
 
-    \sa SerialPort::baudRate
+    \sa QSerialPort::baudRate
 */
 
 /*!
-    \property SerialPort::dataBits
+    \property QSerialPort::dataBits
     \brief the data bits in a frame
 
     If the setting is successful, returns true; otherwise returns false and sets
     an error code which can be obtained by calling the error() method.
 */
-bool SerialPort::setDataBits(DataBits dataBits)
+bool QSerialPort::setDataBits(DataBits dataBits)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (d->setDataBits(dataBits)) {
         d->dataBits = dataBits;
         emit dataBitsChanged(d->dataBits);
@@ -647,32 +647,32 @@ bool SerialPort::setDataBits(DataBits dataBits)
     return false;
 }
 
-SerialPort::DataBits SerialPort::dataBits() const
+QSerialPort::DataBits QSerialPort::dataBits() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->dataBits;
 }
 
 /*!
-    \fn void SerialPort::dataBitsChanged(DataBits dataBits)
+    \fn void QSerialPort::dataBitsChanged(DataBits dataBits)
 
     This signal is emitted after the data bits in a frame has been changed. The
     new data bits in a frame is passed as \dataBits.
 
-    \sa SerialPort::dataBits
+    \sa QSerialPort::dataBits
 */
 
 
 /*!
-    \property SerialPort::parity
+    \property QSerialPort::parity
     \brief the parity checking mode
 
     If the setting is successful, returns true; otherwise returns false and sets
     an error code which can be obtained by calling the error() method.
 */
-bool SerialPort::setParity(Parity parity)
+bool QSerialPort::setParity(Parity parity)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (d->setParity(parity)) {
         d->parity = parity;
         emit parityChanged(d->parity);
@@ -681,31 +681,31 @@ bool SerialPort::setParity(Parity parity)
     return false;
 }
 
-SerialPort::Parity SerialPort::parity() const
+QSerialPort::Parity QSerialPort::parity() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->parity;
 }
 
 /*!
-    \fn void SerialPort::parityChanged(Parity parity)
+    \fn void QSerialPort::parityChanged(Parity parity)
 
     This signal is emitted after the parity checking mode has been changed. The
     new parity checking mode is passed as \a parity.
 
-    \sa SerialPort::parity
+    \sa QSerialPort::parity
 */
 
 /*!
-    \property SerialPort::stopBits
+    \property QSerialPort::stopBits
     \brief the number of stop bits in a frame
 
     If the setting is successful, returns true; otherwise returns false and
     sets an error code which can be obtained by calling the error() method.
 */
-bool SerialPort::setStopBits(StopBits stopBits)
+bool QSerialPort::setStopBits(StopBits stopBits)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (d->setStopBits(stopBits)) {
         d->stopBits = stopBits;
         stopBitsChanged(d->stopBits);
@@ -714,31 +714,31 @@ bool SerialPort::setStopBits(StopBits stopBits)
     return false;
 }
 
-SerialPort::StopBits SerialPort::stopBits() const
+QSerialPort::StopBits QSerialPort::stopBits() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->stopBits;
 }
 
 /*!
-    \fn void SerialPort::stopBitsChanged(StopBits stopBits)
+    \fn void QSerialPort::stopBitsChanged(StopBits stopBits)
 
     This signal is emitted after the number of stop bits in a frame has been
     changed. The new number of stop bits in a frame is passed as \a stopBits.
 
-    \sa SerialPort::stopBits
+    \sa QSerialPort::stopBits
 */
 
 /*!
-    \property SerialPort::flowControl
+    \property QSerialPort::flowControl
     \brief the desired flow control mode
 
     If the setting is successful, returns true; otherwise returns false and sets
     an error code which can be obtained by calling the error() method.
 */
-bool SerialPort::setFlowControl(FlowControl flow)
+bool QSerialPort::setFlowControl(FlowControl flow)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (d->setFlowControl(flow)) {
         d->flow = flow;
         flowControlChanged(d->flow);
@@ -747,23 +747,23 @@ bool SerialPort::setFlowControl(FlowControl flow)
     return false;
 }
 
-SerialPort::FlowControl SerialPort::flowControl() const
+QSerialPort::FlowControl QSerialPort::flowControl() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->flow;
 }
 
 /*!
-    \fn void SerialPort::flowControlChanged(FlowControl flow)
+    \fn void QSerialPort::flowControlChanged(FlowControl flow)
 
     This signal is emitted after the flow control mode has been changed. The
     new flow control mode is passed as \a flow.
 
-    \sa SerialPort::flowControl
+    \sa QSerialPort::flowControl
 */
 
 /*!
-    \property SerialPort::dtr
+    \property QSerialPort::dtr
     \brief the state (high or low) of the line signal DTR
 
     If the setting is successful, returns true; otherwise returns false.
@@ -771,9 +771,9 @@ SerialPort::FlowControl SerialPort::flowControl() const
 
     \sa lines()
 */
-bool SerialPort::setDtr(bool set)
+bool QSerialPort::setDtr(bool set)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
 
     bool retval = d->setDtr(set);
     if (retval)
@@ -782,24 +782,24 @@ bool SerialPort::setDtr(bool set)
     return retval;
 }
 
-bool SerialPort::dtr() const
+bool QSerialPort::dtr() const
 {
-    Q_D(const SerialPort);
-    return d->lines() & SerialPort::DtrLine;
+    Q_D(const QSerialPort);
+    return d->lines() & QSerialPort::DtrLine;
 }
 
 /*!
-    \fn void SerialPort::dtrChanged(bool set)
+    \fn void QSerialPort::dtrChanged(bool set)
 
     This signal is emitted after the state (high or low) of the line signal DTR
     has been changed. The new the state (high or low) of the line signal DTR is
     passed as \a set.
 
-    \sa SerialPort::dtr
+    \sa QSerialPort::dtr
 */
 
 /*!
-    \property SerialPort::rts
+    \property QSerialPort::rts
     \brief the state (high or low) of the line signal RTS
 
     If the setting is successful, returns true; otherwise returns false.
@@ -807,9 +807,9 @@ bool SerialPort::dtr() const
 
     \sa lines()
 */
-bool SerialPort::setRts(bool set)
+bool QSerialPort::setRts(bool set)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
 
     bool retval = d->setRts(set);
     if (retval)
@@ -818,33 +818,33 @@ bool SerialPort::setRts(bool set)
     return retval;
 }
 
-bool SerialPort::rts() const
+bool QSerialPort::rts() const
 {
-    Q_D(const SerialPort);
-    return d->lines() & SerialPort::RtsLine;
+    Q_D(const QSerialPort);
+    return d->lines() & QSerialPort::RtsLine;
 }
 
 /*!
-    \fn void SerialPort::rtsChanged(bool set)
+    \fn void QSerialPort::rtsChanged(bool set)
 
     This signal is emitted after the state (high or low) of the line signal RTS
     has been changed. The new the state (high or low) of the line signal RTS is
     passed as \a set.
 
-    \sa SerialPort::rts
+    \sa QSerialPort::rts
 */
 
 /*!
     Returns the bitmap states of the line signals.
     From this result, it is possible to allocate the state of the
     desired signal by applying a mask "AND", where the mask is
-    the desired enumeration value from SerialPort::Lines.
+    the desired enumeration value from QSerialPort::Lines.
 
     \sa dtr(), rts(), setDtr(), setRts()
 */
-SerialPort::Lines SerialPort::lines() const
+QSerialPort::Lines QSerialPort::lines() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->lines();
 }
 
@@ -856,15 +856,15 @@ SerialPort::Lines SerialPort::lines() const
     Call this function for sending the buffered data immediately to the serial
     port. The number of bytes successfully written depends on the operating
     system. In most cases, this function does not need to be called, because the
-    SerialPort class will start sending data automatically once control is
+    QSerialPort class will start sending data automatically once control is
     returned to the event loop. In the absence of an event loop, call
     waitForBytesWritten() instead.
 
     \sa write(), waitForBytesWritten()
 */
-bool SerialPort::flush()
+bool QSerialPort::flush()
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->flush();
 }
 
@@ -874,9 +874,9 @@ bool SerialPort::flush()
     the UART (driver) buffers. Also terminate pending read or write operations.
     If successful, returns true; otherwise returns false.
 */
-bool SerialPort::clear(Directions dir)
+bool QSerialPort::clear(Directions dir)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     if (dir & Input)
         d->readBuffer.clear();
     if (dir & Output)
@@ -893,8 +893,8 @@ bool SerialPort::clear(Directions dir)
     serial port in a loop. For example:
 
     \code
-    // This slot is connected to SerialPort::readyRead()
-    void SerialPortClass::readyReadSlot()
+    // This slot is connected to QSerialPort::readyRead()
+    void QSerialPortClass::readyReadSlot()
     {
         while (!port.atEnd()) {
             QByteArray data = port.read(100);
@@ -905,23 +905,23 @@ bool SerialPort::clear(Directions dir)
 
      \sa bytesAvailable(), readyRead()
  */
-bool SerialPort::atEnd() const
+bool QSerialPort::atEnd() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return QIODevice::atEnd() && (!isOpen() || (d->bytesAvailable() == 0));
 }
 
 /*!
-    \property SerialPort::dataErrorPolicy
+    \property QSerialPort::dataErrorPolicy
     \brief the error policy how the process receives the character in case of
     parity error detection.
 
     If the setting is successful, returns true; otherwise returns false. The
     default policy set is IgnorePolicy.
 */
-bool SerialPort::setDataErrorPolicy(DataErrorPolicy policy)
+bool QSerialPort::setDataErrorPolicy(DataErrorPolicy policy)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
 
     const bool ret = d->policy == policy || d->setDataErrorPolicy(policy);
     if (ret) {
@@ -932,53 +932,53 @@ bool SerialPort::setDataErrorPolicy(DataErrorPolicy policy)
     return ret;
 }
 
-SerialPort::DataErrorPolicy SerialPort::dataErrorPolicy() const
+QSerialPort::DataErrorPolicy QSerialPort::dataErrorPolicy() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->policy;
 }
 
 /*!
-    \fn void SerialPort::errorPolicyChanged(DataErrorPolicy policy)
+    \fn void QSerialPort::errorPolicyChanged(DataErrorPolicy policy)
 
     This signal is emitted after the error policy how the process receives the
     character in case of parity error detection has been changed. The new error
     policy how the process receives the character in case of parity error
     detection is passed as \a policy.
 
-    \sa SerialPort::dataErrorPolicy
+    \sa QSerialPort::dataErrorPolicy
 */
 
 /*!
-    \property SerialPort::error
+    \property QSerialPort::error
     \brief the error status of the serial port
 
     The I/O device status returns an error code. For example, if open()
     returns false, or a read/write operation returns -1, this property can
     be used to figure out the reason why the operation failed.
 
-    The error code is set to the default SerialPort::NoError after a call to
+    The error code is set to the default QSerialPort::NoError after a call to
     clearError()
 */
-SerialPort::PortError SerialPort::error() const
+QSerialPort::PortError QSerialPort::error() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->portError;
 }
 
-void SerialPort::clearError()
+void QSerialPort::clearError()
 {
-    Q_D(SerialPort);
-    d->portError = SerialPort::NoError;
+    Q_D(QSerialPort);
+    d->portError = QSerialPort::NoError;
 }
 
 /*!
-    \fn void SerialPort::errorChanged(PortError error)
+    \fn void QSerialPort::errorChanged(PortError error)
 
     This signal is emitted after the error has been changed. The new erroris
     passed as \a error.
 
-    \sa SerialPort::error
+    \sa QSerialPort::error
 */
 
 /*!
@@ -991,17 +991,17 @@ void SerialPort::clearError()
 
     \sa setReadBufferSize(), read()
 */
-qint64 SerialPort::readBufferSize() const
+qint64 QSerialPort::readBufferSize() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->readBufferMaxSize;
 }
 
 /*!
-    Sets the size of SerialPort's internal read buffer to be \a
+    Sets the size of QSerialPort's internal read buffer to be \a
     size bytes.
 
-    If the buffer size is limited to a certain size, SerialPort
+    If the buffer size is limited to a certain size, QSerialPort
     will not buffer more than this size of data. Exceptionally, a buffer
     size of 0 means that the read buffer is unlimited and all
     incoming data is buffered. This is the default.
@@ -1013,9 +1013,9 @@ qint64 SerialPort::readBufferSize() const
 
     \sa readBufferSize(), read()
 */
-void SerialPort::setReadBufferSize(qint64 size)
+void QSerialPort::setReadBufferSize(qint64 size)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
 
     if (d->readBufferMaxSize == size)
         return;
@@ -1025,7 +1025,7 @@ void SerialPort::setReadBufferSize(qint64 size)
 /*! \reimp
     Always returns true. The serial port is a sequential device.
 */
-bool SerialPort::isSequential() const
+bool QSerialPort::isSequential() const
 {
     return true;
 }
@@ -1035,9 +1035,9 @@ bool SerialPort::isSequential() const
 
     \sa bytesToWrite(), read()
 */
-qint64 SerialPort::bytesAvailable() const
+qint64 QSerialPort::bytesAvailable() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->bytesAvailable() + QIODevice::bytesAvailable();
 }
 
@@ -1048,9 +1048,9 @@ qint64 SerialPort::bytesAvailable() const
 
     \sa bytesAvailable(), flush()
 */
-qint64 SerialPort::bytesToWrite() const
+qint64 QSerialPort::bytesToWrite() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     return d->writeBuffer.size() + QIODevice::bytesToWrite();
 }
 
@@ -1060,9 +1060,9 @@ qint64 SerialPort::bytesToWrite() const
 
     \sa readLine()
 */
-bool SerialPort::canReadLine() const
+bool QSerialPort::canReadLine() const
 {
-    Q_D(const SerialPort);
+    Q_D(const QSerialPort);
     const bool hasLine = (d->bytesAvailable() > 0) && d->readBuffer.canReadLine();
     return hasLine || QIODevice::canReadLine();
 }
@@ -1078,17 +1078,17 @@ bool SerialPort::canReadLine() const
 
     \sa waitForBytesWritten()
 */
-bool SerialPort::waitForReadyRead(int msecs)
+bool QSerialPort::waitForReadyRead(int msecs)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->waitForReadyRead(msecs);
 }
 
 /*! \reimp
 */
-bool SerialPort::waitForBytesWritten(int msecs)
+bool QSerialPort::waitForBytesWritten(int msecs)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->waitForBytesWritten(msecs);
 }
 
@@ -1105,9 +1105,9 @@ bool SerialPort::waitForBytesWritten(int msecs)
 
     \sa setBreak(), clearBreak()
 */
-bool SerialPort::sendBreak(int duration)
+bool QSerialPort::sendBreak(int duration)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->sendBreak(duration);
 }
 
@@ -1119,37 +1119,37 @@ bool SerialPort::sendBreak(int duration)
 
     \sa clearBreak(), sendBreak()
 */
-bool SerialPort::setBreak(bool set)
+bool QSerialPort::setBreak(bool set)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->setBreak(set);
 }
 
 /*! \reimp
 */
-qint64 SerialPort::readData(char *data, qint64 maxSize)
+qint64 QSerialPort::readData(char *data, qint64 maxSize)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->readFromBuffer(data, maxSize);
 }
 
 /*! \reimp
 */
-qint64 SerialPort::readLineData(char *data, qint64 maxSize)
+qint64 QSerialPort::readLineData(char *data, qint64 maxSize)
 {
     return QIODevice::readLineData(data, maxSize);
 }
 
 /*! \reimp
 */
-qint64 SerialPort::writeData(const char *data, qint64 maxSize)
+qint64 QSerialPort::writeData(const char *data, qint64 maxSize)
 {
-    Q_D(SerialPort);
+    Q_D(QSerialPort);
     return d->writeToBuffer(data, maxSize);
 }
 
 /*!
-    \fn bool SerialPort::clearBreak(bool clear)
+    \fn bool QSerialPort::clearBreak(bool clear)
 
     Controls the signal break, depending on the flag \a clear.
     If successful, returns true; otherwise returns false.
diff --git a/src/serialport/serialport.h b/src/serialport/serialport.h
index 0978f69..c3bd4f8 100644
--- a/src/serialport/serialport.h
+++ b/src/serialport/serialport.h
@@ -40,8 +40,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORT_H
-#define SERIALPORT_H
+#ifndef QSERIALPORT_H
+#define QSERIALPORT_H
 
 #include <QtCore/qiodevice.h>
 
@@ -49,10 +49,10 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortInfo;
-class SerialPortPrivate;
+class QSerialPortInfo;
+class QSerialPortPrivate;
 
-class Q_SERIALPORT_EXPORT SerialPort : public QIODevice
+class Q_SERIALPORT_EXPORT QSerialPort : public QIODevice
 {
     Q_OBJECT
 
@@ -156,13 +156,13 @@ public:
         UnknownPortError
     };
 
-    explicit SerialPort(QObject *parent = 0);
-    explicit SerialPort(const QString &name, QObject *parent = 0);
-    explicit SerialPort(const SerialPortInfo &info, QObject *parent = 0);
-    virtual ~SerialPort();
+    explicit QSerialPort(QObject *parent = 0);
+    explicit QSerialPort(const QString &name, QObject *parent = 0);
+    explicit QSerialPort(const QSerialPortInfo &info, QObject *parent = 0);
+    virtual ~QSerialPort();
 
     void setPort(const QString &port);
-    void setPort(const SerialPortInfo &info);
+    void setPort(const QSerialPortInfo &info);
     QString portName() const;
 
     virtual bool open(OpenMode mode);
@@ -238,18 +238,18 @@ protected:
     virtual qint64 writeData(const char *data, qint64 maxSize);
 
 private:
-    SerialPortPrivate * const d_ptr;
+    QSerialPortPrivate * const d_ptr;
 
-    Q_DECLARE_PRIVATE(SerialPort)
-    Q_DISABLE_COPY(SerialPort)
+    Q_DECLARE_PRIVATE(QSerialPort)
+    Q_DISABLE_COPY(QSerialPort)
 };
 
-inline bool SerialPort::clearBreak(bool clear)
+inline bool QSerialPort::clearBreak(bool clear)
 { return setBreak(!clear); }
 
-Q_DECLARE_OPERATORS_FOR_FLAGS(SerialPort::Directions)
-Q_DECLARE_OPERATORS_FOR_FLAGS(SerialPort::Lines)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QSerialPort::Directions)
+Q_DECLARE_OPERATORS_FOR_FLAGS(QSerialPort::Lines)
 
 QT_END_NAMESPACE_SERIALPORT
 
-#endif // SERIALPORT_H
+#endif // QSERIALPORT_H
diff --git a/src/serialport/serialport_p.h b/src/serialport/serialport_p.h
index 6360b6d..8e299dc 100644
--- a/src/serialport/serialport_p.h
+++ b/src/serialport/serialport_p.h
@@ -41,8 +41,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORT_P_H
-#define SERIALPORT_P_H
+#ifndef QSERIALPORT_P_H
+#define QSERIALPORT_P_H
 
 #include "serialport.h"
 
@@ -54,34 +54,34 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortPrivateData
+class QSerialPortPrivateData
 {
-    Q_DECLARE_PUBLIC(SerialPort)
+    Q_DECLARE_PUBLIC(QSerialPort)
 public:
     enum IoConstants {
         ReadChunkSize = 512,
         WriteChunkSize = 512
     };
 
-    SerialPortPrivateData(SerialPort *q);
+    QSerialPortPrivateData(QSerialPort *q);
     int timeoutValue(int msecs, int elapsed);
 
     qint64 readBufferMaxSize;
     QRingBuffer readBuffer;
     QRingBuffer writeBuffer;
-    SerialPort::PortError portError;
+    QSerialPort::PortError portError;
     QString systemLocation;
     qint32 inputBaudRate;
     qint32 outputBaudRate;
-    SerialPort::DataBits dataBits;
-    SerialPort::Parity parity;
-    SerialPort::StopBits stopBits;
-    SerialPort::FlowControl flow;
-    SerialPort::DataErrorPolicy policy;
+    QSerialPort::DataBits dataBits;
+    QSerialPort::Parity parity;
+    QSerialPort::StopBits stopBits;
+    QSerialPort::FlowControl flow;
+    QSerialPort::DataErrorPolicy policy;
     bool restoreSettingsOnClose;
-    SerialPort * const q_ptr;
+    QSerialPort * const q_ptr;
 };
 
 QT_END_NAMESPACE_SERIALPORT
 
-#endif // SERIALPORT_P_H
+#endif // QSERIALPORT_P_H
diff --git a/src/serialport/serialport_symbian.cpp b/src/serialport/serialport_symbian.cpp
index a8913d8..6edf589 100644
--- a/src/serialport/serialport_symbian.cpp
+++ b/src/serialport/serialport_symbian.cpp
@@ -92,19 +92,19 @@ static bool loadDevices()
     return true;
 }
 
-SerialPortPrivate::SerialPortPrivate(SerialPort *q)
-    : SerialPortPrivateData(q)
+QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
+    : QSerialPortPrivateData(q)
     , errnum(KErrNone)
 {
 }
 
-bool SerialPortPrivate::open(QIODevice::OpenMode mode)
+bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     // FIXME: Maybe need added check an ReadWrite open mode?
     Q_UNUSED(mode)
 
     if (!loadDevices()) {
-        portError = SerialPort::UnknownPortError;
+        portError = QSerialPort::UnknownPortError;
         return false;
     }
 
@@ -149,39 +149,39 @@ bool SerialPortPrivate::open(QIODevice::OpenMode mode)
     return true;
 }
 
-void SerialPortPrivate::close()
+void QSerialPortPrivate::close()
 {
     if (restoreSettingsOnClose)
         descriptor.SetConfig(restoredSettings);
     descriptor.Close();
 }
 
-SerialPort::Lines SerialPortPrivate::lines() const
+QSerialPort::Lines QSerialPortPrivate::lines() const
 {
-    SerialPort::Lines ret = 0;
+    QSerialPort::Lines ret = 0;
 
     TUint signalMask = 0;
     descriptor.Signals(signalMask);
 
     if (signalMask & KSignalCTS)
-        ret |= SerialPort::CtsLine;
+        ret |= QSerialPort::CtsLine;
     if (signalMask & KSignalDSR)
-        ret |= SerialPort::DsrLine;
+        ret |= QSerialPort::DsrLine;
     if (signalMask & KSignalDCD)
-        ret |= SerialPort::DcdLine;
+        ret |= QSerialPort::DcdLine;
     if (signalMask & KSignalRNG)
-        ret |= SerialPort::RiLine;
+        ret |= QSerialPort::RiLine;
     if (signalMask & KSignalRTS)
-        ret |= SerialPort::RtsLine;
+        ret |= QSerialPort::RtsLine;
     if (signalMask & KSignalDTR)
-        ret |= SerialPort::DtrLine;
+        ret |= QSerialPort::DtrLine;
 
     //if (signalMask & KSignalBreak)
     //  ret |=
     return ret;
 }
 
-bool SerialPortPrivate::setDtr(bool set)
+bool QSerialPortPrivate::setDtr(bool set)
 {
     TInt r;
     if (set)
@@ -192,7 +192,7 @@ bool SerialPortPrivate::setDtr(bool set)
     return r == KErrNone;
 }
 
-bool SerialPortPrivate::setRts(bool set)
+bool QSerialPortPrivate::setRts(bool set)
 {
     TInt r;
     if (set)
@@ -203,80 +203,80 @@ bool SerialPortPrivate::setRts(bool set)
     return r == KErrNone;
 }
 
-bool SerialPortPrivate::flush()
+bool QSerialPortPrivate::flush()
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::clear(SerialPort::Directions dir)
+bool QSerialPortPrivate::clear(QSerialPort::Directions dir)
 {
     TUint flags = 0;
-    if (dir & SerialPort::Input)
+    if (dir & QSerialPort::Input)
         flags |= KCommResetRx;
-    if (dir & SerialPort::Output)
+    if (dir & QSerialPort::Output)
         flags |= KCommResetTx;
     TInt r = descriptor.ResetBuffers(flags);
     return r == KErrNone;
 }
 
-bool SerialPortPrivate::sendBreak(int duration)
+bool QSerialPortPrivate::sendBreak(int duration)
 {
     TRequestStatus status;
     descriptor.Break(status, TTimeIntervalMicroSeconds32(duration * 1000));
     return false;
 }
 
-bool SerialPortPrivate::setBreak(bool set)
+bool QSerialPortPrivate::setBreak(bool set)
 {
     // TODO: Implement me
     return false;
 }
 
-qint64 SerialPortPrivate::systemInputQueueSize () const
+qint64 QSerialPortPrivate::systemInputQueueSize () const
 {
     return descriptor.QueryReceiveBuffer();
 }
 
-qint64 SerialPortPrivate::systemOutputQueueSize () const
+qint64 QSerialPortPrivate::systemOutputQueueSize () const
 {
     // TODO: Implement me
     return 0;
 }
 
-qint64 SerialPortPrivate::bytesAvailable() const
+qint64 QSerialPortPrivate::bytesAvailable() const
 {
     return readBuffer.size();
 }
 
-qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
 {
     // TODO: Implement me
     return -1;
 }
 
-qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 {
     // TODO: Implement me
     return -1;
 }
 
-bool SerialPortPrivate::waitForReadyRead(int msec)
+bool QSerialPortPrivate::waitForReadyRead(int msec)
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::waitForBytesWritten(int msec)
+bool QSerialPortPrivate::waitForBytesWritten(int msec)
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
+bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
-    if (dir != SerialPort::AllDirections) {
-        portError = SerialPort::UnsupportedPortOperationError;
+    if (dir != QSerialPort::AllDirections) {
+        portError = QSerialPort::UnsupportedPortOperationError;
         return false;
     }
 
@@ -284,26 +284,26 @@ bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
     if (baudRate)
         currentSettings().iRate = static_cast<TBps>(baudRate);
     else {
-        portError = SerialPort::UnsupportedPortOperationError;
+        portError = QSerialPort::UnsupportedPortOperationError;
         return false;
     }
 
     return updateCommConfig();
 }
 
-bool SerialPortPrivate::setDataBits(SerialPort::DataBits dataBits)
+bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)
 {
     switch (dataBits) {
-    case SerialPort::Data5:
+    case QSerialPort::Data5:
         currentSettings().iDataBits = EData5;
         break;
-    case SerialPort::Data6:
+    case QSerialPort::Data6:
         currentSettings().iDataBits = EData6;
         break;
-    case SerialPort::Data7:
+    case QSerialPort::Data7:
         currentSettings().iDataBits = EData7;
         break;
-    case SerialPort::Data8:
+    case QSerialPort::Data8:
         currentSettings().iDataBits = EData8;
         break;
     default:
@@ -314,22 +314,22 @@ bool SerialPortPrivate::setDataBits(SerialPort::DataBits dataBits)
     return updateCommConfig();
 }
 
-bool SerialPortPrivate::setParity(SerialPort::Parity parity)
+bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)
 {
     switch (parity) {
-    case SerialPort::NoParity:
+    case QSerialPort::NoParity:
         currentSettings().iParity = EParityNone;
         break;
-    case SerialPort::EvenParity:
+    case QSerialPort::EvenParity:
         currentSettings().iParity = EParityEven;
         break;
-    case SerialPort::OddParity:
+    case QSerialPort::OddParity:
         currentSettings().iParity = EParityOdd;
         break;
-    case SerialPort::MarkParity:
+    case QSerialPort::MarkParity:
         currentSettings().iParity = EParityMark;
         break;
-    case SerialPort::SpaceParity:
+    case QSerialPort::SpaceParity:
         currentSettings().iParity = EParitySpace;
         break;
     default:
@@ -340,13 +340,13 @@ bool SerialPortPrivate::setParity(SerialPort::Parity parity)
     return updateCommConfig();
 }
 
-bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
+bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)
 {
     switch (stopBits) {
-    case SerialPort::OneStop:
+    case QSerialPort::OneStop:
         currentSettings().iStopBits = EStop1;
         break;
-    case SerialPort::TwoStop:
+    case QSerialPort::TwoStop:
         currentSettings().iStopBits = EStop2;
         break;
     default:
@@ -357,16 +357,16 @@ bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
     return updateCommConfig();
 }
 
-bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
+bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flow)
 {
     switch (flow) {
-    case SerialPort::NoFlowControl:
+    case QSerialPort::NoFlowControl:
         currentSettings().iHandshake = KConfigFailDSR;
         break;
-    case SerialPort::HardwareControl:
+    case QSerialPort::HardwareControl:
         currentSettings().iHandshake = KConfigObeyCTS | KConfigFreeRTS;
         break;
-    case SerialPort::SoftwareControl:
+    case QSerialPort::SoftwareControl:
         currentSettings().iHandshake = KConfigObeyXoff | KConfigSendXoff;
         break;
     default:
@@ -377,34 +377,34 @@ bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
     return updateCommConfig();
 }
 
-bool SerialPortPrivate::setDataErrorPolicy(SerialPort::DataErrorPolicy policy)
+bool QSerialPortPrivate::setDataErrorPolicy(QSerialPort::DataErrorPolicy policy)
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::notifyRead()
+bool QSerialPortPrivate::notifyRead()
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::notifyWrite()
+bool QSerialPortPrivate::notifyWrite()
 {
     // TODO: Implement me
     return false;
 }
 
-bool SerialPortPrivate::updateCommConfig()
+bool QSerialPortPrivate::updateCommConfig()
 {
     if (descriptor.SetConfig(currentSettings) != KErrNone) {
-        portError = SerialPort::UnsupportedPortOperationError;
+        portError = QSerialPort::UnsupportedPortOperationError;
         return false;
     }
     return true;
 }
 
-void SerialPortPrivate::detectDefaultSettings()
+void QSerialPortPrivate::detectDefaultSettings()
 {
     // Detect baud rate.
     inputBaudRate = baudRateFromSetting(currentSettings().iRate);
@@ -413,91 +413,91 @@ void SerialPortPrivate::detectDefaultSettings()
     // Detect databits.
     switch (currentSettings().iDataBits) {
     case EData5:
-        dataBits = SerialPort::Data5;
+        dataBits = QSerialPort::Data5;
         break;
     case EData6:
-        dataBits = SerialPort::Data6;
+        dataBits = QSerialPort::Data6;
         break;
     case EData7:
-        dataBits = SerialPort::Data7;
+        dataBits = QSerialPort::Data7;
         break;
     case EData8:
-        dataBits = SerialPort::Data8;
+        dataBits = QSerialPort::Data8;
         break;
     default:
-        dataBits = SerialPort::UnknownDataBits;
+        dataBits = QSerialPort::UnknownDataBits;
         break;
     }
 
     // Detect parity.
     switch (currentSettings().iParity) {
     case EParityNone:
-        parity = SerialPort::NoParity;
+        parity = QSerialPort::NoParity;
         break;
     case EParityEven:
-        parity = SerialPort::EvenParity;
+        parity = QSerialPort::EvenParity;
         break;
     case EParityOdd:
-        parity = SerialPort::OddParity;
+        parity = QSerialPort::OddParity;
         break;
     case EParityMark:
-        parity = SerialPort::MarkParity;
+        parity = QSerialPort::MarkParity;
         break;
     case EParitySpace:
-        parity = SerialPort::SpaceParity;
+        parity = QSerialPort::SpaceParity;
         break;
     default:
-        parity = SerialPort::UnknownParity;
+        parity = QSerialPort::UnknownParity;
         break;
     }
 
     // Detect stopbits.
     switch (currentSettings().iStopBits) {
     case EStop1:
-        stopBits = SerialPort::OneStop;
+        stopBits = QSerialPort::OneStop;
         break;
     case EStop2:
-        stopBits = SerialPort::TwoStop;
+        stopBits = QSerialPort::TwoStop;
         break;
     default:
-        stopBits = SerialPort::UnknownStopBits;
+        stopBits = QSerialPort::UnknownStopBits;
         break;
     }
 
     // Detect flow control.
     if ((currentSettings().iHandshake & (KConfigObeyXoff | KConfigSendXoff))
             == (KConfigObeyXoff | KConfigSendXoff))
-        flow = SerialPort::SoftwareControl;
+        flow = QSerialPort::SoftwareControl;
     else if ((currentSettings().iHandshake & (KConfigObeyCTS | KConfigFreeRTS))
              == (KConfigObeyCTS | KConfigFreeRTS))
-        flow = SerialPort::HardwareControl;
+        flow = QSerialPort::HardwareControl;
     else if (currentSettings().iHandshake & KConfigFailDSR)
-        flow = SerialPort::NoFlowControl;
+        flow = QSerialPort::NoFlowControl;
     else
-        flow = SerialPort::UnknownFlowControl;
+        flow = QSerialPort::UnknownFlowControl;
 }
 
-SerialPort::PortError SerialPortPrivate::decodeSystemError() const
+QSerialPort::PortError QSerialPortPrivate::decodeSystemError() const
 {
-    SerialPort::PortError error;
+    QSerialPort::PortError error;
     switch (errnum) {
     case KErrPermissionDenied:
-        error = SerialPort::NoSuchDeviceError;
+        error = QSerialPort::NoSuchDeviceError;
         break;
     case KErrLocked:
-        error = SerialPort::PermissionDeniedError;
+        error = QSerialPort::PermissionDeniedError;
         break;
     case KErrAccessDenied:
-        error = SerialPort::PermissionDeniedError;
+        error = QSerialPort::PermissionDeniedError;
         break;
     default:
-        error = SerialPort::UnknownPortError;
+        error = QSerialPort::UnknownPortError;
         break;
     }
     return error;
 }
 
-bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
+bool QSerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
                                            bool checkRead, bool checkWrite,
                                            int msecs, bool *timedOut)
 {
@@ -566,13 +566,13 @@ bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForW
     return result;
 }
 
-QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
+QString QSerialPortPrivate::portNameToSystemLocation(const QString &port)
 {
     // Port name is equval to port systemLocation.
     return port;
 }
 
-QString SerialPortPrivate::portNameFromSystemLocation(const QString &location)
+QString QSerialPortPrivate::portNameFromSystemLocation(const QString &location)
 {
     // Port name is equval to port systemLocation.
     return location;
@@ -623,21 +623,21 @@ static const BaudRatePair standardBaudRatesTable[] =
 static const BaudRatePair *standardBaudRatesTable_end =
         standardBaudRatesTable + sizeof(standardBaudRatesTable)/sizeof(*standardBaudRatesTable);
 
-qint32 SerialPortPrivate::baudRateFromSetting(qint32 setting)
+qint32 QSerialPortPrivate::baudRateFromSetting(qint32 setting)
 {
     const BaudRatePair rp = { 0, setting };
     const BaudRatePair *ret = qFind(standardaBaudRatesTable, standardBaudRatesTable_end, rp);
     return ret != standardBaudRatesTable_end ? ret->baudRate : 0;
 }
 
-qint32 SerialPortPrivate::settingFromBaudRate(qint32 baudRate)
+qint32 QSerialPortPrivate::settingFromBaudRate(qint32 baudRate)
 {
     const BaudRatePair rp = { baudRate, 0 };
     const BaudRatePair *ret = qBinaryFind(standardBaudRatesTable, standardBaudRatesTable_end, rp);
     return ret != standardBaudRatesTable_end ? ret->setting : 0;
 }
 
-QList<qint32> SerialPortPrivate::standardBaudRates()
+QList<qint32> QSerialPortPrivate::standardBaudRates()
 {
     QList<qint32> ret;
     for (const BaudRatePair *it = standardBaudRatesTable; it != standardBaudRatesTable_end; ++it)
diff --git a/src/serialport/serialport_symbian_p.h b/src/serialport/serialport_symbian_p.h
index 7cf2a60..3c5548d 100644
--- a/src/serialport/serialport_symbian_p.h
+++ b/src/serialport/serialport_symbian_p.h
@@ -39,8 +39,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORT_SYMBIAN_P_H
-#define SERIALPORT_SYMBIAN_P_H
+#ifndef QSERIALPORT_SYMBIAN_P_H
+#define QSERIALPORT_SYMBIAN_P_H
 
 #include "serialport_p.h"
 
@@ -48,21 +48,21 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortPrivate : public SerialPortPrivateData
+class QSerialPortPrivate : public QSerialPortPrivateData
 {
 public:
-    SerialPortPrivate(SerialPort *q);
+    QSerialPortPrivate(QSerialPort *q);
 
     bool open(QIODevice::OpenMode mode);
     void close();
 
-    SerialPort::Lines lines() const;
+    QSerialPort::Lines lines() const;
 
     bool setDtr(bool set);
     bool setRts(bool set);
 
     bool flush();
-    bool clear(SerialPort::Directions dir);
+    bool clear(QSerialPort::Directions dir);
 
     bool sendBreak(int duration);
     bool setBreak(bool set);
@@ -78,12 +78,12 @@ public:
     bool waitForReadyRead(int msec);
     bool waitForBytesWritten(int msec);
 
-    bool setBaudRate(qint32 baudRate, SerialPort::Directions dir);
-    bool setDataBits(SerialPort::DataBits dataBits);
-    bool setParity(SerialPort::Parity parity);
-    bool setStopBits(SerialPort::StopBits stopBits);
-    bool setFlowControl(SerialPort::FlowControl flowControl);
-    bool setDataErrorPolicy(SerialPort::DataErrorPolicy policy);
+    bool setBaudRate(qint32 baudRate, QSerialPort::Directions dir);
+    bool setDataBits(QSerialPort::DataBits dataBits);
+    bool setParity(QSerialPort::Parity parity);
+    bool setStopBits(QSerialPort::StopBits stopBits);
+    bool setFlowControl(QSerialPort::FlowControl flowControl);
+    bool setDataErrorPolicy(QSerialPort::DataErrorPolicy policy);
 
     bool notifyRead();
     bool notifyWrite();
@@ -106,7 +106,7 @@ private:
     bool updateCommConfig();
 
     void detectDefaultSettings();
-    SerialPort::PortError decodeSystemError() const;
+    QSerialPort::PortError decodeSystemError() const;
 
     bool waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
                             bool checkRead, bool checkWrite,
@@ -115,4 +115,4 @@ private:
 
 QT_END_NAMESPACE_SERIALPORT
 
-#endif // SERIALPORT_SYMBIAN_P_H
+#endif // QSERIALPORT_SYMBIAN_P_H
diff --git a/src/serialport/serialport_unix.cpp b/src/serialport/serialport_unix.cpp
index da4ac2f..f2663d1 100644
--- a/src/serialport/serialport_unix.cpp
+++ b/src/serialport/serialport_unix.cpp
@@ -65,7 +65,7 @@ QT_BEGIN_NAMESPACE_SERIALPORT
 class ReadNotifier : public QSocketNotifier
 {
 public:
-    ReadNotifier(SerialPortPrivate *d, QObject *parent)
+    ReadNotifier(QSerialPortPrivate *d, QObject *parent)
         : QSocketNotifier(d->descriptor, QSocketNotifier::Read, parent)
         , dptr(d)
     {}
@@ -79,13 +79,13 @@ protected:
     }
 
 private:
-    SerialPortPrivate *dptr;
+    QSerialPortPrivate *dptr;
 };
 
 class WriteNotifier : public QSocketNotifier
 {
 public:
-    WriteNotifier(SerialPortPrivate *d, QObject *parent)
+    WriteNotifier(QSerialPortPrivate *d, QObject *parent)
         : QSocketNotifier(d->descriptor, QSocketNotifier::Write, parent)
         , dptr(d)
     {}
@@ -94,18 +94,18 @@ protected:
     virtual bool event(QEvent *e) {
         bool ret = QSocketNotifier::event(e);
         if (ret)
-            dptr->writeNotification(SerialPortPrivateData::WriteChunkSize);
+            dptr->writeNotification(QSerialPortPrivateData::WriteChunkSize);
         return ret;
     }
 
 private:
-    SerialPortPrivate *dptr;
+    QSerialPortPrivate *dptr;
 };
 
 class ExceptionNotifier : public QSocketNotifier
 {
 public:
-    ExceptionNotifier(SerialPortPrivate *d, QObject *parent)
+    ExceptionNotifier(QSerialPortPrivate *d, QObject *parent)
         : QSocketNotifier(d->descriptor, QSocketNotifier::Exception, parent)
         , dptr(d)
     {}
@@ -119,11 +119,11 @@ protected:
     }
 
 private:
-    SerialPortPrivate *dptr;
+    QSerialPortPrivate *dptr;
 };
 
-SerialPortPrivate::SerialPortPrivate(SerialPort *q)
-    : SerialPortPrivateData(q)
+QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
+    : QSerialPortPrivateData(q)
     , descriptor(-1)
     , isCustomBaudRateSupported(false)
     , readNotifier(0)
@@ -137,14 +137,14 @@ SerialPortPrivate::SerialPortPrivate(SerialPort *q)
 {
 }
 
-bool SerialPortPrivate::open(QIODevice::OpenMode mode)
+bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     QByteArray portName = portNameFromSystemLocation(systemLocation).toLocal8Bit();
     const char *ptr = portName.constData();
 
     bool byCurrPid = false;
     if (TtyLocker::isLocked(ptr, &byCurrPid)) {
-        portError = SerialPort::PermissionDeniedError;
+        portError = QSerialPort::PermissionDeniedError;
         return false;
     }
 
@@ -173,7 +173,7 @@ bool SerialPortPrivate::open(QIODevice::OpenMode mode)
 
     TtyLocker::lock(ptr);
     if (!TtyLocker::isLocked(ptr, &byCurrPid)) {
-        portError = SerialPort::PermissionDeniedError;
+        portError = QSerialPort::PermissionDeniedError;
         return false;
     }
 
@@ -207,7 +207,7 @@ bool SerialPortPrivate::open(QIODevice::OpenMode mode)
     return true;
 }
 
-void SerialPortPrivate::close()
+void QSerialPortPrivate::close()
 {
     if (restoreSettingsOnClose) {
         ::tcsetattr(descriptor, TCSANOW, &restoredTermios);
@@ -252,94 +252,94 @@ void SerialPortPrivate::close()
     isCustomBaudRateSupported = false;
 }
 
-SerialPort::Lines SerialPortPrivate::lines() const
+QSerialPort::Lines QSerialPortPrivate::lines() const
 {
     int arg = 0;
-    SerialPort::Lines ret = 0;
+    QSerialPort::Lines ret = 0;
 
     if (::ioctl(descriptor, TIOCMGET, &arg) == -1)
         return ret;
 
 #ifdef TIOCM_LE
     if (arg & TIOCM_LE)
-        ret |= SerialPort::LeLine;
+        ret |= QSerialPort::LeLine;
 #endif
 #ifdef TIOCM_DTR
     if (arg & TIOCM_DTR)
-        ret |= SerialPort::DtrLine;
+        ret |= QSerialPort::DtrLine;
 #endif
 #ifdef TIOCM_RTS
     if (arg & TIOCM_RTS)
-        ret |= SerialPort::RtsLine;
+        ret |= QSerialPort::RtsLine;
 #endif
 #ifdef TIOCM_ST
     if (arg & TIOCM_ST)
-        ret |= SerialPort::StLine;
+        ret |= QSerialPort::StLine;
 #endif
 #ifdef TIOCM_SR
     if (arg & TIOCM_SR)
-        ret |= SerialPort::SrLine;
+        ret |= QSerialPort::SrLine;
 #endif
 #ifdef TIOCM_CTS
     if (arg & TIOCM_CTS)
-        ret |= SerialPort::CtsLine;
+        ret |= QSerialPort::CtsLine;
 #endif
 #ifdef TIOCM_CAR
     if (arg & TIOCM_CAR)
-        ret |= SerialPort::DcdLine;
+        ret |= QSerialPort::DcdLine;
 #elif defined TIOCM_CD
     if (arg & TIOCM_CD)
-        ret |= SerialPort::DcdLine;
+        ret |= QSerialPort::DcdLine;
 #endif
 #ifdef TIOCM_RNG
     if (arg & TIOCM_RNG)
-        ret |= SerialPort::RiLine;
+        ret |= QSerialPort::RiLine;
 #elif defined TIOCM_RI
     if (arg & TIOCM_RI)
-        ret |= SerialPort::RiLine;
+        ret |= QSerialPort::RiLine;
 #endif
 #ifdef TIOCM_DSR
     if (arg & TIOCM_DSR)
-        ret |= SerialPort::DsrLine;
+        ret |= QSerialPort::DsrLine;
 #endif
 
     return ret;
 }
 
-bool SerialPortPrivate::setDtr(bool set)
+bool QSerialPortPrivate::setDtr(bool set)
 {
     int status = TIOCM_DTR;
     return ::ioctl(descriptor, set ? TIOCMBIS : TIOCMBIC, &status) != -1;
 }
 
-bool SerialPortPrivate::setRts(bool set)
+bool QSerialPortPrivate::setRts(bool set)
 {
     int status = TIOCM_RTS;
     return ::ioctl(descriptor, set ? TIOCMBIS : TIOCMBIC, &status) != -1;
 }
 
-bool SerialPortPrivate::flush()
+bool QSerialPortPrivate::flush()
 {
     return writeNotification() && (::tcdrain(descriptor) != -1);
 }
 
-bool SerialPortPrivate::clear(SerialPort::Directions dir)
+bool QSerialPortPrivate::clear(QSerialPort::Directions dir)
 {
-    return ::tcflush(descriptor, (dir == SerialPort::AllDirections)
-                     ? TCIOFLUSH : (dir & SerialPort::Input) ? TCIFLUSH : TCOFLUSH) != -1;
+    return ::tcflush(descriptor, (dir == QSerialPort::AllDirections)
+                     ? TCIOFLUSH : (dir & QSerialPort::Input) ? TCIFLUSH : TCOFLUSH) != -1;
 }
 
-bool SerialPortPrivate::sendBreak(int duration)
+bool QSerialPortPrivate::sendBreak(int duration)
 {
     return ::tcsendbreak(descriptor, duration) != -1;
 }
 
-bool SerialPortPrivate::setBreak(bool set)
+bool QSerialPortPrivate::setBreak(bool set)
 {
     return ::ioctl(descriptor, set ? TIOCSBRK : TIOCCBRK) != -1;
 }
 
-qint64 SerialPortPrivate::systemInputQueueSize () const
+qint64 QSerialPortPrivate::systemInputQueueSize () const
 {
     int nbytes = 0;
 #ifdef TIOCINQ
@@ -349,7 +349,7 @@ qint64 SerialPortPrivate::systemInputQueueSize () const
     return nbytes;
 }
 
-qint64 SerialPortPrivate::systemOutputQueueSize () const
+qint64 QSerialPortPrivate::systemOutputQueueSize () const
 {
     int nbytes = 0;
 #ifdef TIOCOUTQ
@@ -359,12 +359,12 @@ qint64 SerialPortPrivate::systemOutputQueueSize () const
     return nbytes;
 }
 
-qint64 SerialPortPrivate::bytesAvailable() const
+qint64 QSerialPortPrivate::bytesAvailable() const
 {
     return readBuffer.size();
 }
 
-qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
 {
     if (readBuffer.isEmpty())
         return 0;
@@ -399,7 +399,7 @@ qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
     return readSoFar;
 }
 
-qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 {
     char *ptr = writeBuffer.reserve(maxSize);
     if (maxSize == 1)
@@ -415,7 +415,7 @@ qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
     return written;
 }
 
-bool SerialPortPrivate::waitForReadyRead(int msecs)
+bool QSerialPortPrivate::waitForReadyRead(int msecs)
 {
     QElapsedTimer stopWatch;
 
@@ -443,7 +443,7 @@ bool SerialPortPrivate::waitForReadyRead(int msecs)
     return false;
 }
 
-bool SerialPortPrivate::waitForBytesWritten(int msecs)
+bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 {
     if (writeBuffer.isEmpty())
         return false;
@@ -471,14 +471,14 @@ bool SerialPortPrivate::waitForBytesWritten(int msecs)
     return false;
 }
 
-bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
+bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
     bool ret = baudRate > 0;
 
     // prepare section
 
     if (ret) {
-        const qint32 unixBaudRate = SerialPortPrivate::settingFromBaudRate(baudRate);
+        const qint32 unixBaudRate = QSerialPortPrivate::settingFromBaudRate(baudRate);
         if (unixBaudRate > 0) {
             // try prepate to set standard baud rate
 #ifdef Q_OS_LINUX
@@ -490,8 +490,8 @@ bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
             }
 #endif
             // prepare to set standard baud rate
-            ret = !(((dir & SerialPort::Input) && ::cfsetispeed(&currentTermios, unixBaudRate) < 0)
-                    || ((dir & SerialPort::Output) && ::cfsetospeed(&currentTermios, unixBaudRate) < 0));
+            ret = !(((dir & QSerialPort::Input) && ::cfsetispeed(&currentTermios, unixBaudRate) < 0)
+                    || ((dir & QSerialPort::Output) && ::cfsetospeed(&currentTermios, unixBaudRate) < 0));
         } else {
             // try prepate to set custom baud rate
 #ifdef Q_OS_LINUX
@@ -541,20 +541,20 @@ bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
     return ret;
 }
 
-bool SerialPortPrivate::setDataBits(SerialPort::DataBits dataBits)
+bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)
 {
     currentTermios.c_cflag &= ~CSIZE;
     switch (dataBits) {
-    case SerialPort::Data5:
+    case QSerialPort::Data5:
         currentTermios.c_cflag |= CS5;
         break;
-    case SerialPort::Data6:
+    case QSerialPort::Data6:
         currentTermios.c_cflag |= CS6;
         break;
-    case SerialPort::Data7:
+    case QSerialPort::Data7:
         currentTermios.c_cflag |= CS7;
         break;
-    case SerialPort::Data8:
+    case QSerialPort::Data8:
         currentTermios.c_cflag |= CS8;
         break;
     default:
@@ -564,7 +564,7 @@ bool SerialPortPrivate::setDataBits(SerialPort::DataBits dataBits)
     return updateTermios();
 }
 
-bool SerialPortPrivate::setParity(SerialPort::Parity parity)
+bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)
 {
     currentTermios.c_iflag &= ~(PARMRK | INPCK);
     currentTermios.c_iflag |= IGNPAR;
@@ -573,22 +573,22 @@ bool SerialPortPrivate::setParity(SerialPort::Parity parity)
 
 #ifdef CMSPAR
     // Here Installation parity only for GNU/Linux where the macro CMSPAR.
-    case SerialPort::SpaceParity:
+    case QSerialPort::SpaceParity:
         currentTermios.c_cflag &= ~PARODD;
         currentTermios.c_cflag |= PARENB | CMSPAR;
         break;
-    case SerialPort::MarkParity:
+    case QSerialPort::MarkParity:
         currentTermios.c_cflag |= PARENB | CMSPAR | PARODD;
         break;
 #endif
-    case SerialPort::NoParity:
+    case QSerialPort::NoParity:
         currentTermios.c_cflag &= ~PARENB;
         break;
-    case SerialPort::EvenParity:
+    case QSerialPort::EvenParity:
         currentTermios.c_cflag &= ~PARODD;
         currentTermios.c_cflag |= PARENB;
         break;
-    case SerialPort::OddParity:
+    case QSerialPort::OddParity:
         currentTermios.c_cflag |= PARENB | PARODD;
         break;
     default:
@@ -601,13 +601,13 @@ bool SerialPortPrivate::setParity(SerialPort::Parity parity)
     return updateTermios();
 }
 
-bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
+bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)
 {
     switch (stopBits) {
-    case SerialPort::OneStop:
+    case QSerialPort::OneStop:
         currentTermios.c_cflag &= ~CSTOPB;
         break;
-    case SerialPort::TwoStop:
+    case QSerialPort::TwoStop:
         currentTermios.c_cflag |= CSTOPB;
         break;
     default:
@@ -617,18 +617,18 @@ bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
     return updateTermios();
 }
 
-bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
+bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flow)
 {
     switch (flow) {
-    case SerialPort::NoFlowControl:
+    case QSerialPort::NoFlowControl:
         currentTermios.c_cflag &= ~CRTSCTS;
         currentTermios.c_iflag &= ~(IXON | IXOFF | IXANY);
         break;
-    case SerialPort::HardwareControl:
+    case QSerialPort::HardwareControl:
         currentTermios.c_cflag |= CRTSCTS;
         currentTermios.c_iflag &= ~(IXON | IXOFF | IXANY);
         break;
-    case SerialPort::SoftwareControl:
+    case QSerialPort::SoftwareControl:
         currentTermios.c_cflag &= ~CRTSCTS;
         currentTermios.c_iflag |= IXON | IXOFF | IXANY;
         break;
@@ -640,29 +640,29 @@ bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
     return updateTermios();
 }
 
-bool SerialPortPrivate::setDataErrorPolicy(SerialPort::DataErrorPolicy policy)
+bool QSerialPortPrivate::setDataErrorPolicy(QSerialPort::DataErrorPolicy policy)
 {
     tcflag_t parmrkMask = PARMRK;
 #ifndef CMSPAR
     // in space/mark parity emulation also used PARMRK flag
-    if (parity == SerialPort::SpaceParity
-            || parity == SerialPort::MarkParity) {
+    if (parity == QSerialPort::SpaceParity
+            || parity == QSerialPort::MarkParity) {
         parmrkMask = 0;
     }
 #endif //CMSPAR
     switch (policy) {
-    case SerialPort::SkipPolicy:
+    case QSerialPort::SkipPolicy:
         currentTermios.c_iflag &= ~parmrkMask;
         currentTermios.c_iflag |= IGNPAR | INPCK;
         break;
-    case SerialPort::PassZeroPolicy:
+    case QSerialPort::PassZeroPolicy:
         currentTermios.c_iflag &= ~(IGNPAR | parmrkMask);
         currentTermios.c_iflag |= INPCK;
         break;
-    case SerialPort::IgnorePolicy:
+    case QSerialPort::IgnorePolicy:
         currentTermios.c_iflag &= ~INPCK;
         break;
-    case SerialPort::StopReceivingPolicy:
+    case QSerialPort::StopReceivingPolicy:
         currentTermios.c_iflag &= ~IGNPAR;
         currentTermios.c_iflag |= parmrkMask | INPCK;
         break;
@@ -673,7 +673,7 @@ bool SerialPortPrivate::setDataErrorPolicy(SerialPort::DataErrorPolicy policy)
     return updateTermios();
 }
 
-bool SerialPortPrivate::readNotification()
+bool QSerialPortPrivate::readNotification()
 {
     // Prevent recursive calls
     if (readPortNotifierCalled) {
@@ -688,7 +688,7 @@ bool SerialPortPrivate::readNotification()
 
     // Always buffered, read data from the port into the read buffer
     qint64 newBytes = readBuffer.size();
-    qint64 bytesToRead = policy == SerialPort::IgnorePolicy ? ReadChunkSize : 1;
+    qint64 bytesToRead = policy == QSerialPort::IgnorePolicy ? ReadChunkSize : 1;
 
     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
         bytesToRead = readBufferMaxSize - readBuffer.size();
@@ -736,7 +736,7 @@ bool SerialPortPrivate::readNotification()
     return true;
 }
 
-bool SerialPortPrivate::writeNotification(int maxSize)
+bool QSerialPortPrivate::writeNotification(int maxSize)
 {
     const int tmp = writeBuffer.size();
 
@@ -773,13 +773,13 @@ bool SerialPortPrivate::writeNotification(int maxSize)
     return (writeBuffer.size() < tmp);
 }
 
-bool SerialPortPrivate::exceptionNotification()
+bool QSerialPortPrivate::exceptionNotification()
 {
     // FIXME:
     return false;
 }
 
-bool SerialPortPrivate::updateTermios()
+bool QSerialPortPrivate::updateTermios()
 {
     if (::tcsetattr(descriptor, TCSANOW, &currentTermios) == -1) {
         portError = decodeSystemError();
@@ -788,7 +788,7 @@ bool SerialPortPrivate::updateTermios()
     return true;
 }
 
-void SerialPortPrivate::detectDefaultSettings()
+void QSerialPortPrivate::detectDefaultSettings()
 {
     // Detect baud rate.
     const speed_t inputUnixBaudRate = ::cfgetispeed(&currentTermios);
@@ -823,26 +823,26 @@ void SerialPortPrivate::detectDefaultSettings()
     // other *nix
 #endif
     if (!isCustomBaudRateSupported || !isCustomBaudRateCurrentSet) {
-        inputBaudRate = SerialPortPrivate::baudRateFromSetting(inputUnixBaudRate);
-        outputBaudRate = SerialPortPrivate::baudRateFromSetting(outputUnixBaudRate);
+        inputBaudRate = QSerialPortPrivate::baudRateFromSetting(inputUnixBaudRate);
+        outputBaudRate = QSerialPortPrivate::baudRateFromSetting(outputUnixBaudRate);
     }
 
     // Detect databits.
     switch (currentTermios.c_cflag & CSIZE) {
     case CS5:
-        dataBits = SerialPort::Data5;
+        dataBits = QSerialPort::Data5;
         break;
     case CS6:
-        dataBits = SerialPort::Data6;
+        dataBits = QSerialPort::Data6;
         break;
     case CS7:
-        dataBits = SerialPort::Data7;
+        dataBits = QSerialPort::Data7;
         break;
     case CS8:
-        dataBits = SerialPort::Data8;
+        dataBits = QSerialPort::Data8;
         break;
     default:
-        dataBits = SerialPort::UnknownDataBits;
+        dataBits = QSerialPort::UnknownDataBits;
         break;
     }
 
@@ -850,14 +850,14 @@ void SerialPortPrivate::detectDefaultSettings()
 #ifdef CMSPAR
     if (currentTermios.c_cflag & CMSPAR) {
         parity = currentTermios.c_cflag & PARODD ?
-                    SerialPort::MarkParity : SerialPort::SpaceParity;
+                    QSerialPort::MarkParity : QSerialPort::SpaceParity;
     } else {
 #endif
         if (currentTermios.c_cflag & PARENB) {
             parity = currentTermios.c_cflag & PARODD ?
-                        SerialPort::OddParity : SerialPort::EvenParity;
+                        QSerialPort::OddParity : QSerialPort::EvenParity;
         } else {
-            parity = SerialPort::NoParity;
+            parity = QSerialPort::NoParity;
         }
 #ifdef CMSPAR
     }
@@ -865,48 +865,48 @@ void SerialPortPrivate::detectDefaultSettings()
 
     // Detect stopbits.
     stopBits = currentTermios.c_cflag & CSTOPB ?
-                SerialPort::TwoStop : SerialPort::OneStop;
+                QSerialPort::TwoStop : QSerialPort::OneStop;
 
     // Detect flow control.
     if ((!(currentTermios.c_cflag & CRTSCTS)) && (!(currentTermios.c_iflag & (IXON | IXOFF | IXANY))))
-        flow = SerialPort::NoFlowControl;
+        flow = QSerialPort::NoFlowControl;
     else if ((!(currentTermios.c_cflag & CRTSCTS)) && (currentTermios.c_iflag & (IXON | IXOFF | IXANY)))
-        flow = SerialPort::SoftwareControl;
+        flow = QSerialPort::SoftwareControl;
     else if ((currentTermios.c_cflag & CRTSCTS) && (!(currentTermios.c_iflag & (IXON | IXOFF | IXANY))))
-        flow = SerialPort::HardwareControl;
+        flow = QSerialPort::HardwareControl;
     else
-        flow = SerialPort::UnknownFlowControl;
+        flow = QSerialPort::UnknownFlowControl;
 }
 
-SerialPort::PortError SerialPortPrivate::decodeSystemError() const
+QSerialPort::PortError QSerialPortPrivate::decodeSystemError() const
 {
-    SerialPort::PortError error;
+    QSerialPort::PortError error;
     switch (errno) {
     case ENODEV:
-        error = SerialPort::NoSuchDeviceError;
+        error = QSerialPort::NoSuchDeviceError;
         break;
     case EACCES:
-        error = SerialPort::PermissionDeniedError;
+        error = QSerialPort::PermissionDeniedError;
         break;
     case EBUSY:
-        error = SerialPort::PermissionDeniedError;
+        error = QSerialPort::PermissionDeniedError;
         break;
     case ENOTTY:
-        error = SerialPort::IoError;
+        error = QSerialPort::IoError;
         break;
     default:
-        error = SerialPort::UnknownPortError;
+        error = QSerialPort::UnknownPortError;
         break;
     }
     return error;
 }
 
-bool SerialPortPrivate::isReadNotificationEnabled() const
+bool QSerialPortPrivate::isReadNotificationEnabled() const
 {
     return readNotifier && readNotifier->isEnabled();
 }
 
-void SerialPortPrivate::setReadNotificationEnabled(bool enable)
+void QSerialPortPrivate::setReadNotificationEnabled(bool enable)
 {
     if (readNotifier) {
         readNotifier->setEnabled(enable);
@@ -916,12 +916,12 @@ void SerialPortPrivate::setReadNotificationEnabled(bool enable)
     }
 }
 
-bool SerialPortPrivate::isWriteNotificationEnabled() const
+bool QSerialPortPrivate::isWriteNotificationEnabled() const
 {
     return writeNotifier && writeNotifier->isEnabled();
 }
 
-void SerialPortPrivate::setWriteNotificationEnabled(bool enable)
+void QSerialPortPrivate::setWriteNotificationEnabled(bool enable)
 {
     if (writeNotifier) {
         writeNotifier->setEnabled(enable);
@@ -931,12 +931,12 @@ void SerialPortPrivate::setWriteNotificationEnabled(bool enable)
     }
 }
 
-bool SerialPortPrivate::isExceptionNotificationEnabled() const
+bool QSerialPortPrivate::isExceptionNotificationEnabled() const
 {
     return exceptionNotifier && exceptionNotifier->isEnabled();
 }
 
-void SerialPortPrivate::setExceptionNotificationEnabled(bool enable)
+void QSerialPortPrivate::setExceptionNotificationEnabled(bool enable)
 {
     if (exceptionNotifier) {
         exceptionNotifier->setEnabled(enable);
@@ -946,7 +946,7 @@ void SerialPortPrivate::setExceptionNotificationEnabled(bool enable)
     }
 }
 
-bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
+bool QSerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
                                            bool checkRead, bool checkWrite,
                                            int msecs, bool *timedOut)
 {
@@ -982,15 +982,15 @@ bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForW
     return ret;
 }
 
-qint64 SerialPortPrivate::readFromPort(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readFromPort(char *data, qint64 maxSize)
 {
     qint64 bytesRead = 0;
 #if defined (CMSPAR)
-    if (parity == SerialPort::NoParity
-            || policy != SerialPort::StopReceivingPolicy) {
+    if (parity == QSerialPort::NoParity
+            || policy != QSerialPort::StopReceivingPolicy) {
 #else
-    if (parity != SerialPort::MarkParity
-            && parity != SerialPort::SpaceParity) {
+    if (parity != QSerialPort::MarkParity
+            && parity != QSerialPort::SpaceParity) {
 #endif
         bytesRead = ::read(descriptor, data, maxSize);
     } else {// Perform parity emulation.
@@ -1023,14 +1023,14 @@ qint64 SerialPortPrivate::readFromPort(char *data, qint64 maxSize)
     return bytesRead;
 }
 
-qint64 SerialPortPrivate::writeToPort(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writeToPort(const char *data, qint64 maxSize)
 {
     qint64 bytesWritten = 0;
 #if defined (CMSPAR)
     bytesWritten = ::write(descriptor, data, maxSize);
 #else
-    if (parity != SerialPort::MarkParity
-            && parity != SerialPort::SpaceParity) {
+    if (parity != QSerialPort::MarkParity
+            && parity != QSerialPort::SpaceParity) {
         bytesWritten = ::write(descriptor, data, maxSize);
     } else {// Perform parity emulation.
         bytesWritten = writePerChar(data, maxSize);
@@ -1067,7 +1067,7 @@ static inline bool evenParity(quint8 c)
 
 #ifndef CMSPAR
 
-qint64 SerialPortPrivate::writePerChar(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writePerChar(const char *data, qint64 maxSize)
 {
     qint64 ret = 0;
     quint8 const charMask = (0xFF >> (8 - dataBits));
@@ -1076,7 +1076,7 @@ qint64 SerialPortPrivate::writePerChar(const char *data, qint64 maxSize)
 
         bool par = evenParity(*data & charMask);
         // False if need EVEN, true if need ODD.
-        par ^= parity == SerialPort::MarkParity;
+        par ^= parity == QSerialPort::MarkParity;
         if (par ^ (currentTermios.c_cflag & PARODD)) { // Need switch parity mode?
             currentTermios.c_cflag ^= PARODD;
             flush(); //force sending already buffered data, because updateTermios() cleares buffers
@@ -1098,7 +1098,7 @@ qint64 SerialPortPrivate::writePerChar(const char *data, qint64 maxSize)
 
 #endif //CMSPAR
 
-qint64 SerialPortPrivate::readPerChar(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readPerChar(char *data, qint64 maxSize)
 {
     qint64 ret = 0;
     quint8 const charMask = (0xFF >> (8 - dataBits));
@@ -1141,24 +1141,24 @@ qint64 SerialPortPrivate::readPerChar(char *data, qint64 maxSize)
         // Now: par contains parity ok or error, *data contains received character
         par ^= evenParity(*data & charMask); //par contains parity bit value for EVEN mode
         par ^= (currentTermios.c_cflag & PARODD); //par contains parity bit value for current mode
-        if (par ^ (parity == SerialPort::SpaceParity)) { //if parity error
+        if (par ^ (parity == QSerialPort::SpaceParity)) { //if parity error
             switch (policy) {
-            case SerialPort::SkipPolicy:
+            case QSerialPort::SkipPolicy:
                 continue;       //ignore received character
-            case SerialPort::StopReceivingPolicy:
-                if (parity != SerialPort::NoParity)
-                    portError = SerialPort::ParityError;
+            case QSerialPort::StopReceivingPolicy:
+                if (parity != QSerialPort::NoParity)
+                    portError = QSerialPort::ParityError;
                 else
                     portError = *data == '\0' ?
-                                SerialPort::BreakConditionError : SerialPort::FramingError;
+                                QSerialPort::BreakConditionError : QSerialPort::FramingError;
                 return ++ret;   //abort receiving
                 break;
-            case SerialPort::UnknownPolicy:
+            case QSerialPort::UnknownPolicy:
                 // Unknown error policy is used! Falling back to PassZeroPolicy
-            case SerialPort::PassZeroPolicy:
+            case QSerialPort::PassZeroPolicy:
                 *data = '\0';   //replace received character by zero
                 break;
-            case SerialPort::IgnorePolicy:
+            case QSerialPort::IgnorePolicy:
                 break;          //ignore error and pass received character
             }
         }
@@ -1175,7 +1175,7 @@ static const QLatin1String notUsedPathPrefix("/dev/tty.");
 static const QLatin1String defaultPathPrefix("/dev/");
 #endif
 
-QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
+QString QSerialPortPrivate::portNameToSystemLocation(const QString &port)
 {
     QString ret = port;
 
@@ -1188,7 +1188,7 @@ QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
     return ret;
 }
 
-QString SerialPortPrivate::portNameFromSystemLocation(const QString &location)
+QString QSerialPortPrivate::portNameFromSystemLocation(const QString &location)
 {
     QString ret = location;
 
@@ -1307,21 +1307,21 @@ static const BaudRatePair standardBaudRatesTable[] =
 static const BaudRatePair *standardBaudRatesTable_end =
         standardBaudRatesTable + sizeof(standardBaudRatesTable)/sizeof(*standardBaudRatesTable);
 
-qint32 SerialPortPrivate::baudRateFromSetting(qint32 setting)
+qint32 QSerialPortPrivate::baudRateFromSetting(qint32 setting)
 {
     const BaudRatePair rp = { 0, setting };
     const BaudRatePair *ret = qFind(standardBaudRatesTable, standardBaudRatesTable_end, rp);
     return ret != standardBaudRatesTable_end ? ret->baudRate : 0;
 }
 
-qint32 SerialPortPrivate::settingFromBaudRate(qint32 baudRate)
+qint32 QSerialPortPrivate::settingFromBaudRate(qint32 baudRate)
 {
     const BaudRatePair rp = { baudRate, 0 };
     const BaudRatePair *ret = qBinaryFind(standardBaudRatesTable, standardBaudRatesTable_end, rp);
     return ret != standardBaudRatesTable_end ? ret->setting : 0;
 }
 
-QList<qint32> SerialPortPrivate::standardBaudRates()
+QList<qint32> QSerialPortPrivate::standardBaudRates()
 {
     QList<qint32> ret;
     for (const BaudRatePair *it = standardBaudRatesTable; it != standardBaudRatesTable_end; ++it)
diff --git a/src/serialport/serialport_unix_p.h b/src/serialport/serialport_unix_p.h
index 768472d..2ee5c7f 100644
--- a/src/serialport/serialport_unix_p.h
+++ b/src/serialport/serialport_unix_p.h
@@ -40,8 +40,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORT_UNIX_P_H
-#define SERIALPORT_UNIX_P_H
+#ifndef QSERIALPORT_UNIX_P_H
+#define QSERIALPORT_UNIX_P_H
 
 #include "serialport_p.h"
 
@@ -55,21 +55,21 @@ class QSocketNotifier;
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortPrivate : public SerialPortPrivateData
+class QSerialPortPrivate : public QSerialPortPrivateData
 {
 public:
-    SerialPortPrivate(SerialPort *q);
+    QSerialPortPrivate(QSerialPort *q);
 
     bool open(QIODevice::OpenMode mode);
     void close();
 
-    SerialPort::Lines lines() const;
+    QSerialPort::Lines lines() const;
 
     bool setDtr(bool set);
     bool setRts(bool set);
 
     bool flush();
-    bool clear(SerialPort::Directions dir);
+    bool clear(QSerialPort::Directions dir);
 
     bool sendBreak(int duration);
     bool setBreak(bool set);
@@ -85,12 +85,12 @@ public:
     bool waitForReadyRead(int msecs);
     bool waitForBytesWritten(int msecs);
 
-    bool setBaudRate(qint32 baudRate, SerialPort::Directions dir);
-    bool setDataBits(SerialPort::DataBits dataBits);
-    bool setParity(SerialPort::Parity parity);
-    bool setStopBits(SerialPort::StopBits stopBits);
-    bool setFlowControl(SerialPort::FlowControl flow);
-    bool setDataErrorPolicy(SerialPort::DataErrorPolicy policy);
+    bool setBaudRate(qint32 baudRate, QSerialPort::Directions dir);
+    bool setDataBits(QSerialPort::DataBits dataBits);
+    bool setParity(QSerialPort::Parity parity);
+    bool setStopBits(QSerialPort::StopBits stopBits);
+    bool setFlowControl(QSerialPort::FlowControl flow);
+    bool setDataErrorPolicy(QSerialPort::DataErrorPolicy policy);
 
     bool readNotification();
     bool writeNotification(int maxSize = INT_MAX);
@@ -128,7 +128,7 @@ private:
     bool updateTermios();
 
     void detectDefaultSettings();
-    SerialPort::PortError decodeSystemError() const;
+    QSerialPort::PortError decodeSystemError() const;
 
     bool isReadNotificationEnabled() const;
     void setReadNotificationEnabled(bool enable);
@@ -153,4 +153,4 @@ private:
 
 QT_END_NAMESPACE_SERIALPORT
 
-#endif // SERIALPORT_UNIX_P_H
+#endif // QSERIALPORT_UNIX_P_H
diff --git a/src/serialport/serialport_win.cpp b/src/serialport/serialport_win.cpp
index 7f4d0ba..ecdb050 100644
--- a/src/serialport/serialport_win.cpp
+++ b/src/serialport/serialport_win.cpp
@@ -94,7 +94,7 @@ class AbstractOverlappedEventNotifier : public QWinEventNotifier
 public:
     enum Type { CommEvent, ReadCompletionEvent, WriteCompletionEvent };
 
-    AbstractOverlappedEventNotifier(SerialPortPrivate *d, Type type, bool manual, QObject *parent)
+    AbstractOverlappedEventNotifier(QSerialPortPrivate *d, Type type, bool manual, QObject *parent)
         : QWinEventNotifier(parent), dptr(d), t(type) {
         ::memset(&o, 0, sizeof(o));
         o.hEvent = ::CreateEvent(NULL, manual, FALSE, NULL);
@@ -120,7 +120,7 @@ protected:
         return ret;
     }
 
-    SerialPortPrivate *dptr;
+    QSerialPortPrivate *dptr;
     Type t;
     OVERLAPPED o;
 };
@@ -128,7 +128,7 @@ protected:
 class CommOverlappedEventNotifier : public AbstractOverlappedEventNotifier
 {
 public:
-    CommOverlappedEventNotifier(SerialPortPrivate *d, DWORD eventMask, QObject *parent)
+    CommOverlappedEventNotifier(QSerialPortPrivate *d, DWORD eventMask, QObject *parent)
         : AbstractOverlappedEventNotifier(d, CommEvent, false, parent)
         , originalEventMask(eventMask), triggeredEventMask(0) {
         ::SetCommMask(dptr->descriptor, originalEventMask);
@@ -154,7 +154,7 @@ private:
 class ReadOverlappedCompletionNotifier : public AbstractOverlappedEventNotifier
 {
 public:
-    ReadOverlappedCompletionNotifier(SerialPortPrivate *d, QObject *parent)
+    ReadOverlappedCompletionNotifier(QSerialPortPrivate *d, QObject *parent)
         : AbstractOverlappedEventNotifier(d, ReadCompletionEvent, false, parent) {}
 
     virtual bool processCompletionRoutine() {
@@ -179,7 +179,7 @@ public:
 class WriteOverlappedCompletionNotifier : public AbstractOverlappedEventNotifier
 {
 public:
-    WriteOverlappedCompletionNotifier(SerialPortPrivate *d, QObject *parent)
+    WriteOverlappedCompletionNotifier(QSerialPortPrivate *d, QObject *parent)
         : AbstractOverlappedEventNotifier(d, WriteCompletionEvent, false, parent) {}
 
     virtual bool processCompletionRoutine() {
@@ -190,8 +190,8 @@ public:
     }
 };
 
-SerialPortPrivate::SerialPortPrivate(SerialPort *q)
-    : SerialPortPrivateData(q)
+QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
+    : QSerialPortPrivateData(q)
     , descriptor(INVALID_HANDLE_VALUE)
     , flagErrorFromCommEvent(false)
     , actualReadBufferSize(0)
@@ -202,7 +202,7 @@ SerialPortPrivate::SerialPortPrivate(SerialPort *q)
 {
 }
 
-bool SerialPortPrivate::open(QIODevice::OpenMode mode)
+bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     DWORD desiredAccess = 0;
     DWORD originalEventMask = EV_ERR;
@@ -261,7 +261,7 @@ bool SerialPortPrivate::open(QIODevice::OpenMode mode)
     return true;
 }
 
-void SerialPortPrivate::close()
+void QSerialPortPrivate::close()
 {
     ::CancelIo(descriptor);
 
@@ -290,22 +290,22 @@ void SerialPortPrivate::close()
 
 #endif // #ifndef Q_OS_WINCE
 
-SerialPort::Lines SerialPortPrivate::lines() const
+QSerialPort::Lines QSerialPortPrivate::lines() const
 {
     DWORD modemStat = 0;
-    SerialPort::Lines ret = 0;
+    QSerialPort::Lines ret = 0;
 
     if (!::GetCommModemStatus(descriptor, &modemStat))
         return ret;
 
     if (modemStat & MS_CTS_ON)
-        ret |= SerialPort::CtsLine;
+        ret |= QSerialPort::CtsLine;
     if (modemStat & MS_DSR_ON)
-        ret |= SerialPort::DsrLine;
+        ret |= QSerialPort::DsrLine;
     if (modemStat & MS_RING_ON)
-        ret |= SerialPort::RiLine;
+        ret |= QSerialPort::RiLine;
     if (modemStat & MS_RLSD_ON)
-        ret |= SerialPort::DcdLine;
+        ret |= QSerialPort::DcdLine;
 
     DWORD bytesReturned = 0;
     if (::DeviceIoControl(descriptor, IOCTL_SERIAL_GET_DTRRTS, NULL, 0,
@@ -313,39 +313,39 @@ SerialPort::Lines SerialPortPrivate::lines() const
                           &bytesReturned, NULL)) {
 
         if (modemStat & SERIAL_DTR_STATE)
-            ret |= SerialPort::DtrLine;
+            ret |= QSerialPort::DtrLine;
         if (modemStat & SERIAL_RTS_STATE)
-            ret |= SerialPort::RtsLine;
+            ret |= QSerialPort::RtsLine;
     }
 
     return ret;
 }
 
-bool SerialPortPrivate::setDtr(bool set)
+bool QSerialPortPrivate::setDtr(bool set)
 {
     return ::EscapeCommFunction(descriptor, set ? SETDTR : CLRDTR);
 }
 
-bool SerialPortPrivate::setRts(bool set)
+bool QSerialPortPrivate::setRts(bool set)
 {
     return ::EscapeCommFunction(descriptor, set ? SETRTS : CLRRTS);
 }
 
 #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::flush()
+bool QSerialPortPrivate::flush()
 {
     return startAsyncWrite() && ::FlushFileBuffers(descriptor);
 }
 
-bool SerialPortPrivate::clear(SerialPort::Directions dir)
+bool QSerialPortPrivate::clear(QSerialPort::Directions dir)
 {
     DWORD flags = 0;
-    if (dir & SerialPort::Input) {
+    if (dir & QSerialPort::Input) {
         flags |= PURGE_RXABORT | PURGE_RXCLEAR;
         actualReadBufferSize = 0;
     }
-    if (dir & SerialPort::Output) {
+    if (dir & QSerialPort::Output) {
         flags |= PURGE_TXABORT | PURGE_TXCLEAR;
         actualWriteBufferSize = 0;
         acyncWritePosition = 0;
@@ -356,7 +356,7 @@ bool SerialPortPrivate::clear(SerialPort::Directions dir)
 
 #endif
 
-bool SerialPortPrivate::sendBreak(int duration)
+bool QSerialPortPrivate::sendBreak(int duration)
 {
     // FIXME:
     if (setBreak(true)) {
@@ -367,14 +367,14 @@ bool SerialPortPrivate::sendBreak(int duration)
     return false;
 }
 
-bool SerialPortPrivate::setBreak(bool set)
+bool QSerialPortPrivate::setBreak(bool set)
 {
     if (set)
         return ::SetCommBreak(descriptor);
     return ::ClearCommBreak(descriptor);
 }
 
-qint64 SerialPortPrivate::systemInputQueueSize () const
+qint64 QSerialPortPrivate::systemInputQueueSize () const
 {
     COMSTAT cs;
     ::memset(&cs, 0, sizeof(cs));
@@ -383,7 +383,7 @@ qint64 SerialPortPrivate::systemInputQueueSize () const
     return cs.cbInQue;
 }
 
-qint64 SerialPortPrivate::systemOutputQueueSize () const
+qint64 QSerialPortPrivate::systemOutputQueueSize () const
 {
     COMSTAT cs;
     ::memset(&cs, 0, sizeof(cs));
@@ -394,12 +394,12 @@ qint64 SerialPortPrivate::systemOutputQueueSize () const
 
 #ifndef Q_OS_WINCE
 
-qint64 SerialPortPrivate::bytesAvailable() const
+qint64 QSerialPortPrivate::bytesAvailable() const
 {
     return actualReadBufferSize;
 }
 
-qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
 {
     if (actualReadBufferSize == 0)
         return 0;
@@ -426,7 +426,7 @@ qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
     return readSoFar;
 }
 
-qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 {
     char *ptr = writeBuffer.reserve(maxSize);
     if (maxSize == 1) {
@@ -443,7 +443,7 @@ qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
     return maxSize;
 }
 
-bool SerialPortPrivate::waitForReadyRead(int msecs)
+bool QSerialPortPrivate::waitForReadyRead(int msecs)
 {
     QElapsedTimer stopWatch;
     stopWatch.start();
@@ -476,7 +476,7 @@ bool SerialPortPrivate::waitForReadyRead(int msecs)
     return false;
 }
 
-bool SerialPortPrivate::waitForBytesWritten(int msecs)
+bool QSerialPortPrivate::waitForBytesWritten(int msecs)
 {
     if (writeBuffer.isEmpty())
         return false;
@@ -512,40 +512,40 @@ bool SerialPortPrivate::waitForBytesWritten(int msecs)
 
 #endif // #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::setBaudRate(qint32 baudRate, SerialPort::Directions dir)
+bool QSerialPortPrivate::setBaudRate(qint32 baudRate, QSerialPort::Directions dir)
 {
-    if (dir != SerialPort::AllDirections) {
-        portError = SerialPort::UnsupportedPortOperationError;
+    if (dir != QSerialPort::AllDirections) {
+        portError = QSerialPort::UnsupportedPortOperationError;
         return false;
     }
     currentDcb.BaudRate = baudRate;
     return updateDcb();
 }
 
-bool SerialPortPrivate::setDataBits(SerialPort::DataBits dataBits)
+bool QSerialPortPrivate::setDataBits(QSerialPort::DataBits dataBits)
 {
     currentDcb.ByteSize = dataBits;
     return updateDcb();
 }
 
-bool SerialPortPrivate::setParity(SerialPort::Parity parity)
+bool QSerialPortPrivate::setParity(QSerialPort::Parity parity)
 {
     currentDcb.fParity = TRUE;
     switch (parity) {
-    case SerialPort::NoParity:
+    case QSerialPort::NoParity:
         currentDcb.Parity = NOPARITY;
         currentDcb.fParity = FALSE;
         break;
-    case SerialPort::OddParity:
+    case QSerialPort::OddParity:
         currentDcb.Parity = ODDPARITY;
         break;
-    case SerialPort::EvenParity:
+    case QSerialPort::EvenParity:
         currentDcb.Parity = EVENPARITY;
         break;
-    case SerialPort::MarkParity:
+    case QSerialPort::MarkParity:
         currentDcb.Parity = MARKPARITY;
         break;
-    case SerialPort::SpaceParity:
+    case QSerialPort::SpaceParity:
         currentDcb.Parity = SPACEPARITY;
         break;
     default:
@@ -556,16 +556,16 @@ bool SerialPortPrivate::setParity(SerialPort::Parity parity)
     return updateDcb();
 }
 
-bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
+bool QSerialPortPrivate::setStopBits(QSerialPort::StopBits stopBits)
 {
     switch (stopBits) {
-    case SerialPort::OneStop:
+    case QSerialPort::OneStop:
         currentDcb.StopBits = ONESTOPBIT;
         break;
-    case SerialPort::OneAndHalfStop:
+    case QSerialPort::OneAndHalfStop:
         currentDcb.StopBits = ONE5STOPBITS;
         break;
-    case SerialPort::TwoStop:
+    case QSerialPort::TwoStop:
         currentDcb.StopBits = TWOSTOPBITS;
         break;
     default:
@@ -575,20 +575,20 @@ bool SerialPortPrivate::setStopBits(SerialPort::StopBits stopBits)
     return updateDcb();
 }
 
-bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
+bool QSerialPortPrivate::setFlowControl(QSerialPort::FlowControl flow)
 {
     currentDcb.fInX = FALSE;
     currentDcb.fOutX = FALSE;
     currentDcb.fOutxCtsFlow = FALSE;
     currentDcb.fRtsControl = RTS_CONTROL_DISABLE;
     switch (flow) {
-    case SerialPort::NoFlowControl:
+    case QSerialPort::NoFlowControl:
         break;
-    case SerialPort::SoftwareControl:
+    case QSerialPort::SoftwareControl:
         currentDcb.fInX = TRUE;
         currentDcb.fOutX = TRUE;
         break;
-    case SerialPort::HardwareControl:
+    case QSerialPort::HardwareControl:
         currentDcb.fOutxCtsFlow = TRUE;
         currentDcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
         break;
@@ -598,7 +598,7 @@ bool SerialPortPrivate::setFlowControl(SerialPort::FlowControl flow)
     return updateDcb();
 }
 
-bool SerialPortPrivate::setDataErrorPolicy(SerialPort::DataErrorPolicy policy)
+bool QSerialPortPrivate::setDataErrorPolicy(QSerialPort::DataErrorPolicy policy)
 {
     policy = policy;
     return true;
@@ -606,9 +606,9 @@ bool SerialPortPrivate::setDataErrorPolicy(SerialPort::DataErrorPolicy policy)
 
 #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::startAsyncRead()
+bool QSerialPortPrivate::startAsyncRead()
 {
-    DWORD bytesToRead = policy == SerialPort::IgnorePolicy ? ReadChunkSize : 1;
+    DWORD bytesToRead = policy == QSerialPort::IgnorePolicy ? ReadChunkSize : 1;
 
     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
         bytesToRead = readBufferMaxSize - readBuffer.size();
@@ -642,7 +642,7 @@ bool SerialPortPrivate::startAsyncRead()
     return false;
 }
 
-bool SerialPortPrivate::startAsyncWrite(int maxSize)
+bool QSerialPortPrivate::startAsyncWrite(int maxSize)
 {
     qint64 nextSize = 0;
     const char *ptr = writeBuffer.readPointerAtPosition(acyncWritePosition, nextSize);
@@ -682,19 +682,19 @@ bool SerialPortPrivate::startAsyncWrite(int maxSize)
 
 #endif // #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::processIoErrors()
+bool QSerialPortPrivate::processIoErrors()
 {
     DWORD error = 0;
     const bool ret = ::ClearCommError(descriptor, &error, NULL);
     if (ret && error) {
         if (error & CE_FRAME)
-            portError = SerialPort::FramingError;
+            portError = QSerialPort::FramingError;
         else if (error & CE_RXPARITY)
-            portError = SerialPort::ParityError;
+            portError = QSerialPort::ParityError;
         else if (error & CE_BREAK)
-            portError = SerialPort::BreakConditionError;
+            portError = QSerialPort::BreakConditionError;
         else
-            portError = SerialPort::UnknownPortError;
+            portError = QSerialPort::UnknownPortError;
 
         flagErrorFromCommEvent = true;
     }
@@ -703,7 +703,7 @@ bool SerialPortPrivate::processIoErrors()
 
 #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
+bool QSerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
 {
     actualReadBufferSize += qint64(numberOfBytes);
     readBuffer.truncate(actualReadBufferSize);
@@ -716,21 +716,21 @@ bool SerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
             flagErrorFromCommEvent = false;
 
             // Ignore received character, remove it from buffer
-            if (policy == SerialPort::SkipPolicy) {
+            if (policy == QSerialPort::SkipPolicy) {
                 readBuffer.getChar();
                 startAsyncRead();
                 return true;
             }
 
             // Abort receiving
-            if (policy == SerialPort::StopReceivingPolicy) {
+            if (policy == QSerialPort::StopReceivingPolicy) {
                 readyReadEmitted = true;
                 emit q_ptr->readyRead();
                 return true;
             }
 
             // Replace received character by zero
-            if (policy == SerialPort::PassZeroPolicy) {
+            if (policy == QSerialPort::PassZeroPolicy) {
                 readBuffer.getChar();
                 readBuffer.putChar('\0');
             }
@@ -743,7 +743,7 @@ bool SerialPortPrivate::completeAsyncRead(DWORD numberOfBytes)
     return true;
 }
 
-bool SerialPortPrivate::completeAsyncWrite(DWORD numberOfBytes)
+bool QSerialPortPrivate::completeAsyncWrite(DWORD numberOfBytes)
 {
     writeBuffer.free(numberOfBytes);
     actualWriteBufferSize -= qint64(numberOfBytes);
@@ -760,7 +760,7 @@ bool SerialPortPrivate::completeAsyncWrite(DWORD numberOfBytes)
     return true;
 }
 
-AbstractOverlappedEventNotifier *SerialPortPrivate::lookupFreeWriteCompletionNotifier()
+AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupFreeWriteCompletionNotifier()
 {
     // find first free not running write notifier
     foreach (AbstractOverlappedEventNotifier *n, notifiers) {
@@ -773,7 +773,7 @@ AbstractOverlappedEventNotifier *SerialPortPrivate::lookupFreeWriteCompletionNot
     return new WriteOverlappedCompletionNotifier(this, q_ptr);
 }
 
-AbstractOverlappedEventNotifier *SerialPortPrivate::lookupCommEventNotifier()
+AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupCommEventNotifier()
 {
     foreach (AbstractOverlappedEventNotifier *n, notifiers) {
         if (n->type() == AbstractOverlappedEventNotifier::CommEvent)
@@ -782,7 +782,7 @@ AbstractOverlappedEventNotifier *SerialPortPrivate::lookupCommEventNotifier()
     return 0;
 }
 
-AbstractOverlappedEventNotifier *SerialPortPrivate::lookupReadCompletionNotifier()
+AbstractOverlappedEventNotifier *QSerialPortPrivate::lookupReadCompletionNotifier()
 {
     foreach (AbstractOverlappedEventNotifier *n, notifiers) {
         if (n->type() == AbstractOverlappedEventNotifier::ReadCompletionEvent)
@@ -791,7 +791,7 @@ AbstractOverlappedEventNotifier *SerialPortPrivate::lookupReadCompletionNotifier
     return 0;
 }
 
-bool SerialPortPrivate::updateDcb()
+bool QSerialPortPrivate::updateDcb()
 {
     if (!::SetCommState(descriptor, &currentDcb)) {
         portError = decodeSystemError();
@@ -800,7 +800,7 @@ bool SerialPortPrivate::updateDcb()
     return true;
 }
 
-bool SerialPortPrivate::updateCommTimeouts()
+bool QSerialPortPrivate::updateCommTimeouts()
 {
     if (!::SetCommTimeouts(descriptor, &currentCommTimeouts)) {
         portError = decodeSystemError();
@@ -811,7 +811,7 @@ bool SerialPortPrivate::updateCommTimeouts()
 
 #endif // #ifndef Q_OS_WINCE
 
-void SerialPortPrivate::detectDefaultSettings()
+void QSerialPortPrivate::detectDefaultSettings()
 {
     // Detect baud rate.
     inputBaudRate = quint32(currentDcb.BaudRate);
@@ -820,84 +820,84 @@ void SerialPortPrivate::detectDefaultSettings()
     // Detect databits.
     switch (currentDcb.ByteSize) {
     case 5:
-        dataBits = SerialPort::Data5;
+        dataBits = QSerialPort::Data5;
         break;
     case 6:
-        dataBits = SerialPort::Data6;
+        dataBits = QSerialPort::Data6;
         break;
     case 7:
-        dataBits = SerialPort::Data7;
+        dataBits = QSerialPort::Data7;
         break;
     case 8:
-        dataBits = SerialPort::Data8;
+        dataBits = QSerialPort::Data8;
         break;
     default:
-        dataBits = SerialPort::UnknownDataBits;
+        dataBits = QSerialPort::UnknownDataBits;
         break;
     }
 
     // Detect parity.
     if ((currentDcb.Parity == NOPARITY) && !currentDcb.fParity)
-        parity = SerialPort::NoParity;
+        parity = QSerialPort::NoParity;
     else if ((currentDcb.Parity == SPACEPARITY) && currentDcb.fParity)
-        parity = SerialPort::SpaceParity;
+        parity = QSerialPort::SpaceParity;
     else if ((currentDcb.Parity == MARKPARITY) && currentDcb.fParity)
-        parity = SerialPort::MarkParity;
+        parity = QSerialPort::MarkParity;
     else if ((currentDcb.Parity == EVENPARITY) && currentDcb.fParity)
-        parity = SerialPort::EvenParity;
+        parity = QSerialPort::EvenParity;
     else if ((currentDcb.Parity == ODDPARITY) && currentDcb.fParity)
-        parity = SerialPort::OddParity;
+        parity = QSerialPort::OddParity;
     else
-        parity = SerialPort::UnknownParity;
+        parity = QSerialPort::UnknownParity;
 
     // Detect stopbits.
     switch (currentDcb.StopBits) {
     case ONESTOPBIT:
-        stopBits = SerialPort::OneStop;
+        stopBits = QSerialPort::OneStop;
         break;
     case ONE5STOPBITS:
-        stopBits = SerialPort::OneAndHalfStop;
+        stopBits = QSerialPort::OneAndHalfStop;
         break;
     case TWOSTOPBITS:
-        stopBits = SerialPort::TwoStop;
+        stopBits = QSerialPort::TwoStop;
         break;
     default:
-        stopBits = SerialPort::UnknownStopBits;
+        stopBits = QSerialPort::UnknownStopBits;
         break;
     }
 
     // Detect flow control.
     if (!currentDcb.fOutxCtsFlow && (currentDcb.fRtsControl == RTS_CONTROL_DISABLE)
             && !currentDcb.fInX && !currentDcb.fOutX) {
-        flow = SerialPort::NoFlowControl;
+        flow = QSerialPort::NoFlowControl;
     } else if (!currentDcb.fOutxCtsFlow && (currentDcb.fRtsControl == RTS_CONTROL_DISABLE)
                && currentDcb.fInX && currentDcb.fOutX) {
-        flow = SerialPort::SoftwareControl;
+        flow = QSerialPort::SoftwareControl;
     } else if (currentDcb.fOutxCtsFlow && (currentDcb.fRtsControl == RTS_CONTROL_HANDSHAKE)
                && !currentDcb.fInX && !currentDcb.fOutX) {
-        flow = SerialPort::HardwareControl;
+        flow = QSerialPort::HardwareControl;
     } else
-        flow = SerialPort::UnknownFlowControl;
+        flow = QSerialPort::UnknownFlowControl;
 }
 
-SerialPort::PortError SerialPortPrivate::decodeSystemError() const
+QSerialPort::PortError QSerialPortPrivate::decodeSystemError() const
 {
-    SerialPort::PortError error;
+    QSerialPort::PortError error;
     switch (::GetLastError()) {
     case ERROR_FILE_NOT_FOUND:
-        error = SerialPort::NoSuchDeviceError;
+        error = QSerialPort::NoSuchDeviceError;
         break;
     case ERROR_ACCESS_DENIED:
-        error = SerialPort::PermissionDeniedError;
+        error = QSerialPort::PermissionDeniedError;
         break;
     case ERROR_INVALID_HANDLE:
-        error = SerialPort::DeviceIsNotOpenedError;
+        error = QSerialPort::DeviceIsNotOpenedError;
         break;
     case ERROR_INVALID_PARAMETER:
-        error = SerialPort::UnsupportedPortOperationError;
+        error = QSerialPort::UnsupportedPortOperationError;
         break;
     default:
-        error = SerialPort::UnknownPortError;
+        error = QSerialPort::UnknownPortError;
         break;
     }
     return error;
@@ -905,7 +905,7 @@ SerialPort::PortError SerialPortPrivate::decodeSystemError() const
 
 #ifndef Q_OS_WINCE
 
-bool SerialPortPrivate::waitAnyEvent(int msecs, bool *timedOut,
+bool QSerialPortPrivate::waitAnyEvent(int msecs, bool *timedOut,
                                      AbstractOverlappedEventNotifier **triggeredNotifier)
 {
     Q_ASSERT(timedOut);
@@ -930,7 +930,7 @@ bool SerialPortPrivate::waitAnyEvent(int msecs, bool *timedOut,
 
 static const QLatin1String defaultPathPrefix("\\\\.\\");
 
-QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
+QString QSerialPortPrivate::portNameToSystemLocation(const QString &port)
 {
     QString ret = port;
     if (!ret.contains(defaultPathPrefix))
@@ -938,7 +938,7 @@ QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
     return ret;
 }
 
-QString SerialPortPrivate::portNameFromSystemLocation(const QString &location)
+QString QSerialPortPrivate::portNameFromSystemLocation(const QString &location)
 {
     QString ret = location;
     if (ret.contains(defaultPathPrefix))
@@ -1002,19 +1002,19 @@ static const qint32 standardBaudRatesTable[] =
 static const qint32 *standardBaudRatesTable_end =
         standardBaudRatesTable + sizeof(standardBaudRatesTable)/sizeof(*standardBaudRatesTable);
 
-qint32 SerialPortPrivate::baudRateFromSetting(qint32 setting)
+qint32 QSerialPortPrivate::baudRateFromSetting(qint32 setting)
 {
     const qint32 *ret = qFind(standardBaudRatesTable, standardBaudRatesTable_end, setting);
     return ret != standardBaudRatesTable_end ? *ret : 0;
 }
 
-qint32 SerialPortPrivate::settingFromBaudRate(qint32 baudRate)
+qint32 QSerialPortPrivate::settingFromBaudRate(qint32 baudRate)
 {
     const qint32 *ret = qBinaryFind(standardBaudRatesTable, standardBaudRatesTable_end, baudRate);
     return ret != standardBaudRatesTable_end ? *ret : 0;
 }
 
-QList<qint32> SerialPortPrivate::standardBaudRates()
+QList<qint32> QSerialPortPrivate::standardBaudRates()
 {
     QList<qint32> l;
     for (const qint32 *it = standardBaudRatesTable; it != standardBaudRatesTable_end; ++it)
diff --git a/src/serialport/serialport_win_p.h b/src/serialport/serialport_win_p.h
index f7feed8..eafa50f 100644
--- a/src/serialport/serialport_win_p.h
+++ b/src/serialport/serialport_win_p.h
@@ -40,8 +40,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORT_WIN_P_H
-#define SERIALPORT_WIN_P_H
+#ifndef QSERIALPORT_WIN_P_H
+#define QSERIALPORT_WIN_P_H
 
 #include "serialport_p.h"
 
@@ -61,21 +61,21 @@ QT_BEGIN_NAMESPACE_SERIALPORT
 class AbstractOverlappedEventNotifier;
 #endif
 
-class SerialPortPrivate : public SerialPortPrivateData
+class QSerialPortPrivate : public QSerialPortPrivateData
 {
 public:
-    SerialPortPrivate(SerialPort *q);
+    QSerialPortPrivate(QSerialPort *q);
 
     bool open(QIODevice::OpenMode mode);
     void close();
 
-    SerialPort::Lines lines() const;
+    QSerialPort::Lines lines() const;
 
     bool setDtr(bool set);
     bool setRts(bool set);
 
     bool flush();
-    bool clear(SerialPort::Directions dir);
+    bool clear(QSerialPort::Directions dir);
 
     bool sendBreak(int duration);
     bool setBreak(bool set);
@@ -91,12 +91,12 @@ public:
     bool waitForReadyRead(int msec);
     bool waitForBytesWritten(int msec);
 
-    bool setBaudRate(qint32 baudRate, SerialPort::Directions dir);
-    bool setDataBits(SerialPort::DataBits dataBits);
-    bool setParity(SerialPort::Parity parity);
-    bool setStopBits(SerialPort::StopBits stopBits);
-    bool setFlowControl(SerialPort::FlowControl flowControl);
-    bool setDataErrorPolicy(SerialPort::DataErrorPolicy policy);
+    bool setBaudRate(qint32 baudRate, QSerialPort::Directions dir);
+    bool setDataBits(QSerialPort::DataBits dataBits);
+    bool setParity(QSerialPort::Parity parity);
+    bool setStopBits(QSerialPort::StopBits stopBits);
+    bool setFlowControl(QSerialPort::FlowControl flowControl);
+    bool setDataErrorPolicy(QSerialPort::DataErrorPolicy policy);
 
     bool processIoErrors();
 #ifndef Q_OS_WINCE
@@ -144,7 +144,7 @@ private:
     bool updateCommTimeouts();
 
     void detectDefaultSettings();
-    SerialPort::PortError decodeSystemError() const;
+    QSerialPort::PortError decodeSystemError() const;
 
 #ifndef Q_OS_WINCE
     bool waitAnyEvent(int msecs, bool *timedOut,
diff --git a/src/serialport/serialport_wince.cpp b/src/serialport/serialport_wince.cpp
index a49e2ed..fca8beb 100644
--- a/src/serialport/serialport_wince.cpp
+++ b/src/serialport/serialport_wince.cpp
@@ -50,7 +50,7 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortPrivate;
+class QSerialPortPrivate;
 
 class CommEventNotifier : public QThread
 {
@@ -59,7 +59,7 @@ signals:
     void eventMask(quint32 mask);
 
 public:
-    CommEventNotifier(DWORD mask, SerialPortPrivate *d, QObject *parent)
+    CommEventNotifier(DWORD mask, QSerialPortPrivate *d, QObject *parent)
         : QThread(parent), dptr(d), running(true) {
         connect(this, SIGNAL(eventMask(quint32)), this, SLOT(processNotification(quint32)));
         ::SetCommMask(dptr->descriptor, mask);
@@ -92,11 +92,11 @@ private slots:
         if (EV_RXCHAR &eventMask)
             dptr->notifyRead();
         if (EV_TXEMPTY & eventMask)
-            dptr->notifyWrite(SerialPortPrivateData::WriteChunkSize);
+            dptr->notifyWrite(QSerialPortPrivateData::WriteChunkSize);
     }
 
 private:
-    SerialPortPrivate *dptr;
+    QSerialPortPrivate *dptr;
     mutable bool running;
 };
 
@@ -143,15 +143,15 @@ private:
     mutable bool worked;
 };
 
-SerialPortPrivate::SerialPortPrivate(SerialPort *q)
-    : SerialPortPrivateData(q)
+QSerialPortPrivate::QSerialPortPrivate(QSerialPort *q)
+    : QSerialPortPrivateData(q)
     , descriptor(INVALID_HANDLE_VALUE)
     , flagErrorFromCommEvent(0)
     , eventNotifier(0)
 {
 }
 
-bool SerialPortPrivate::open(QIODevice::OpenMode mode)
+bool QSerialPortPrivate::open(QIODevice::OpenMode mode)
 {
     DWORD desiredAccess = 0;
     DWORD eventMask = EV_ERR;
@@ -200,14 +200,14 @@ bool SerialPortPrivate::open(QIODevice::OpenMode mode)
     if (!updateCommTimeouts())
         return false;
 
-    eventNotifier = new QtAddOn::SerialPort::CommEventNotifier(eventMask, this, q_ptr);
+    eventNotifier = new QtAddOn::QSerialPort::CommEventNotifier(eventMask, this, q_ptr);
     eventNotifier->start();
 
     detectDefaultSettings();
     return true;
 }
 
-void SerialPortPrivate::close()
+void QSerialPortPrivate::close()
 {
     if (eventNotifier) {
         eventNotifier->deleteLater();
@@ -223,27 +223,27 @@ void SerialPortPrivate::close()
     descriptor = INVALID_HANDLE_VALUE;
 }
 
-bool SerialPortPrivate::flush()
+bool QSerialPortPrivate::flush()
 {
     return notifyWrite() && ::FlushFileBuffers(descriptor);
 }
 
-bool SerialPortPrivate::clear(SerialPort::Directions dir)
+bool QSerialPortPrivate::clear(QSerialPort::Directions dir)
 {
     DWORD flags = 0;
-    if (dir & SerialPort::Input)
+    if (dir & QSerialPort::Input)
         flags |= PURGE_RXABORT | PURGE_RXCLEAR;
-    if (dir & SerialPort::Output)
+    if (dir & QSerialPort::Output)
         flags |= PURGE_TXABORT | PURGE_TXCLEAR;
     return ::PurgeComm(descriptor, flags);
 }
 
-qint64 SerialPortPrivate::bytesAvailable() const
+qint64 QSerialPortPrivate::bytesAvailable() const
 {
     return readBuffer.size();
 }
 
-qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
 {
     if (readBuffer.isEmpty())
         return 0;
@@ -267,7 +267,7 @@ qint64 SerialPortPrivate::readFromBuffer(char *data, qint64 maxSize)
     return readSoFar;
 }
 
-qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
+qint64 QSerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
 {
     char *ptr = writeBuffer.reserve(maxSize);
     if (maxSize == 1)
@@ -278,7 +278,7 @@ qint64 SerialPortPrivate::writeToBuffer(const char *data, qint64 maxSize)
     return maxSize;
 }
 
-bool SerialPortPrivate::waitForReadyRead(int msec)
+bool QSerialPortPrivate::waitForReadyRead(int msec)
 {
     if (!readBuffer.isEmpty())
         return true;
@@ -307,7 +307,7 @@ bool SerialPortPrivate::waitForReadyRead(int msec)
     return false;
 }
 
-bool SerialPortPrivate::waitForBytesWritten(int msec)
+bool QSerialPortPrivate::waitForBytesWritten(int msec)
 {
     if (writeBuffer.isEmpty())
         return false;
@@ -338,9 +338,9 @@ bool SerialPortPrivate::waitForBytesWritten(int msec)
     return false;
 }
 
-bool SerialPortPrivate::notifyRead()
+bool QSerialPortPrivate::notifyRead()
 {
-    DWORD bytesToRead = (policy == SerialPort::IgnorePolicy) ? ReadChunkSize : 1;
+    DWORD bytesToRead = (policy == QSerialPort::IgnorePolicy) ? ReadChunkSize : 1;
 
     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
         bytesToRead = readBufferMaxSize - readBuffer.size();
@@ -368,14 +368,14 @@ bool SerialPortPrivate::notifyRead()
         flagErrorFromCommEvent = false;
 
         switch (policy) {
-        case SerialPort::SkipPolicy:
+        case QSerialPort::SkipPolicy:
             readBuffer.getChar();
             return true;
-        case SerialPort::PassZeroPolicy:
+        case QSerialPort::PassZeroPolicy:
             readBuffer.getChar();
             readBuffer.putChar('\0');
             break;
-        case SerialPort::StopReceivingPolicy:
+        case QSerialPort::StopReceivingPolicy:
             // FIXME: Maybe need disable read notifier?
             break;
         default:
@@ -389,7 +389,7 @@ bool SerialPortPrivate::notifyRead()
     return true;
 }
 
-bool SerialPortPrivate::notifyWrite(int maxSize)
+bool QSerialPortPrivate::notifyWrite(int maxSize)
 {
     int nextSize = qMin(writeBuffer.nextDataBlockSize(), maxSize);
 
@@ -407,7 +407,7 @@ bool SerialPortPrivate::notifyWrite(int maxSize)
     return true;
 }
 
-bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
+bool QSerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForWrite,
                                            bool checkRead, bool checkWrite,
                                            int msecs, bool *timedOut)
 {
@@ -437,7 +437,7 @@ bool SerialPortPrivate::waitForReadOrWrite(bool *selectForRead, bool *selectForW
     return false;
 }
 
-bool SerialPortPrivate::updateDcb()
+bool QSerialPortPrivate::updateDcb()
 {
     QMutexLocker locker(&settingsChangeMutex);
 
@@ -458,7 +458,7 @@ bool SerialPortPrivate::updateDcb()
     return ret;
 }
 
-bool SerialPortPrivate::updateCommTimeouts()
+bool QSerialPortPrivate::updateCommTimeouts()
 {
     if (!::SetCommTimeouts(descriptor, &currentCommTimeouts)) {
         portError = decodeSystemError();
@@ -469,7 +469,7 @@ bool SerialPortPrivate::updateCommTimeouts()
 
 static const QLatin1String defaultPathPostfix(":");
 
-QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
+QString QSerialPortPrivate::portNameToSystemLocation(const QString &port)
 {
     QString ret = port;
     if (!ret.contains(defaultPathPostfix))
@@ -477,7 +477,7 @@ QString SerialPortPrivate::portNameToSystemLocation(const QString &port)
     return ret;
 }
 
-QString SerialPortPrivate::portNameFromSystemLocation(const QString &location)
+QString QSerialPortPrivate::portNameFromSystemLocation(const QString &location)
 {
     QString ret = location;
     if (ret.contains(defaultPathPostfix))
diff --git a/src/serialport/serialportinfo.cpp b/src/serialport/serialportinfo.cpp
index 69b56d8..2cd2fa7 100644
--- a/src/serialport/serialportinfo.cpp
+++ b/src/serialport/serialportinfo.cpp
@@ -49,50 +49,50 @@ QT_BEGIN_NAMESPACE_SERIALPORT
 
 
 /*!
-    \class SerialPortInfo
+    \class QSerialPortInfo
 
-    \brief The SerialPortInfo class provides information about
+    \brief The QSerialPortInfo class provides information about
     existing serial ports.
 
     \ingroup serialport-main
     \inmodule QtSerialPort
     \since 5.0
 
-    Use the static functions to generate a list of SerialPortInfo
-    objects. Each SerialPortInfo object in the list represents a single
+    Use the static functions to generate a list of QSerialPortInfo
+    objects. Each QSerialPortInfo object in the list represents a single
     serial port and can be queried for the port name, system location,
-    description, and manufacturer. The SerialPortInfo class can also be
-    used as an input parameter for the setPort() method of the SerialPort
+    description, and manufacturer. The QSerialPortInfo class can also be
+    used as an input parameter for the setPort() method of the QSerialPort
     class.
 
-    \sa SerialPort
+    \sa QSerialPort
 */
 
 /*!
-    Constructs an empty SerialPortInfo object.
+    Constructs an empty QSerialPortInfo object.
 
     \sa isNull()
 */
-SerialPortInfo::SerialPortInfo()
-    : d_ptr(new SerialPortInfoPrivate)
+QSerialPortInfo::QSerialPortInfo()
+    : d_ptr(new QSerialPortInfoPrivate)
 {
 }
 
 /*!
     Constructs a copy of \a other.
 */
-SerialPortInfo::SerialPortInfo(const SerialPortInfo &other)
-    : d_ptr(other.d_ptr ? new SerialPortInfoPrivate(*other.d_ptr) : 0)
+QSerialPortInfo::QSerialPortInfo(const QSerialPortInfo &other)
+    : d_ptr(other.d_ptr ? new QSerialPortInfoPrivate(*other.d_ptr) : 0)
 {
 }
 
 /*!
-    Constructs a SerialPortInfo object from serial \a port.
+    Constructs a QSerialPortInfo object from serial \a port.
 */
-SerialPortInfo::SerialPortInfo(const SerialPort &port)
-    : d_ptr(new SerialPortInfoPrivate)
+QSerialPortInfo::QSerialPortInfo(const QSerialPort &port)
+    : d_ptr(new QSerialPortInfoPrivate)
 {
-    foreach (const SerialPortInfo &info, availablePorts()) {
+    foreach (const QSerialPortInfo &info, availablePorts()) {
         if (port.portName() == info.portName()) {
             *this = info;
             break;
@@ -101,16 +101,16 @@ SerialPortInfo::SerialPortInfo(const SerialPort &port)
 }
 
 /*!
-    Constructs a SerialPortInfo object from serial port \a name.
+    Constructs a QSerialPortInfo object from serial port \a name.
 
     This constructor finds the relevant serial port among the available ones
     according to the port name \a name, and constructs the serial port info
     instance for that port.
 */
-SerialPortInfo::SerialPortInfo(const QString &name)
-    : d_ptr(new SerialPortInfoPrivate)
+QSerialPortInfo::QSerialPortInfo(const QString &name)
+    : d_ptr(new QSerialPortInfoPrivate)
 {
-    foreach (const SerialPortInfo &info, availablePorts()) {
+    foreach (const QSerialPortInfo &info, availablePorts()) {
         if (name == info.portName()) {
             *this = info;
             break;
@@ -119,47 +119,47 @@ SerialPortInfo::SerialPortInfo(const QString &name)
 }
 
 /*!
-    Destroys the SerialPortInfo object. References to the values in the
+    Destroys the QSerialPortInfo object. References to the values in the
     object become invalid.
 */
-SerialPortInfo::~SerialPortInfo()
+QSerialPortInfo::~QSerialPortInfo()
 {
 }
 
-/*! \fn void SerialPortInfo::swap(SerialPortInfo &other)
+/*! \fn void QSerialPortInfo::swap(QSerialPortInfo &other)
 
-    Swaps SerialPortInfo \a other with this SerialPortInfo. This operation is
+    Swaps QSerialPortInfo \a other with this QSerialPortInfo. This operation is
     very fast and never fails.
 */
-void SerialPortInfo::swap(SerialPortInfo &other)
+void QSerialPortInfo::swap(QSerialPortInfo &other)
 {
     d_ptr.swap(other.d_ptr);
 }
 
 /*!
-    Sets the SerialPortInfo object to be equal to \a other.
+    Sets the QSerialPortInfo object to be equal to \a other.
 */
-SerialPortInfo& SerialPortInfo::operator=(const SerialPortInfo &other)
+QSerialPortInfo& QSerialPortInfo::operator=(const QSerialPortInfo &other)
 {
-    SerialPortInfo(other).swap(*this);
+    QSerialPortInfo(other).swap(*this);
     return *this;
 }
 
 /*!
     Returns the name of the serial port.
 */
-QString SerialPortInfo::portName() const
+QString QSerialPortInfo::portName() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->portName;
 }
 
 /*!
     Returns the system location of the serial port.
 */
-QString SerialPortInfo::systemLocation() const
+QString QSerialPortInfo::systemLocation() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->device;
 }
 
@@ -167,9 +167,9 @@ QString SerialPortInfo::systemLocation() const
     Returns the description string of the serial port,
     if available; otherwise returns an empty string.
 */
-QString SerialPortInfo::description() const
+QString QSerialPortInfo::description() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->description;
 }
 
@@ -177,9 +177,9 @@ QString SerialPortInfo::description() const
     Returns the manufacturer string of the serial port,
     if available; otherwise returns an empty string.
 */
-QString SerialPortInfo::manufacturer() const
+QString QSerialPortInfo::manufacturer() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->manufacturer;
 }
 
@@ -188,9 +188,9 @@ QString SerialPortInfo::manufacturer() const
     port in hexadecimal format, if available; otherwise
     returns an empty string.
 */
-QString SerialPortInfo::vendorIdentifier() const
+QString QSerialPortInfo::vendorIdentifier() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->vendorIdentifier;
 }
 
@@ -199,42 +199,42 @@ QString SerialPortInfo::vendorIdentifier() const
     port in hexadecimal format, if available; otherwise
     returns an empty string.
 */
-QString SerialPortInfo::productIdentifier() const
+QString QSerialPortInfo::productIdentifier() const
 {
-    Q_D(const SerialPortInfo);
+    Q_D(const QSerialPortInfo);
     return !d ? QString() : d->productIdentifier;
 }
 
 /*!
-    \fn bool SerialPortInfo::isNull() const
+    \fn bool QSerialPortInfo::isNull() const
 
-    Returns whether this SerialPortInfo object holds a
+    Returns whether this QSerialPortInfo object holds a
     serial port definition.
 */
 
 /*!
-    \fn bool SerialPortInfo::isBusy() const
+    \fn bool QSerialPortInfo::isBusy() const
 
     Returns true if serial port is busy;
     otherwise returns false.
 */
 
 /*!
-    \fn bool SerialPortInfo::isValid() const
+    \fn bool QSerialPortInfo::isValid() const
 
     Returns true if serial port is present on system;
     otherwise returns false.
 */
 
 /*!
-    \fn QList<qint32> SerialPortInfo::standardRates()
+    \fn QList<qint32> QSerialPortInfo::standardRates()
 
     Returns a list of available standard baud rates supported by
     the current serial port.
 */
 
 /*!
-    \fn QList<SerialPortInfo> SerialPortInfo::availablePorts()
+    \fn QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 
     Returns a list of available serial ports on the system.
 */
diff --git a/src/serialport/serialportinfo.h b/src/serialport/serialportinfo.h
index 345af74..6e76f92 100644
--- a/src/serialport/serialportinfo.h
+++ b/src/serialport/serialportinfo.h
@@ -50,22 +50,22 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPort;
-class SerialPortInfoPrivate;
-class SerialInfoPrivateDeleter;
+class QSerialPort;
+class QSerialPortInfoPrivate;
+class QSerialInfoPrivateDeleter;
 
-class Q_SERIALPORT_EXPORT SerialPortInfo
+class Q_SERIALPORT_EXPORT QSerialPortInfo
 {
-    Q_DECLARE_PRIVATE(SerialPortInfo)
+    Q_DECLARE_PRIVATE(QSerialPortInfo)
 public:
-    SerialPortInfo();
-    SerialPortInfo(const SerialPortInfo &other);
-    SerialPortInfo(const SerialPort &port);
-    SerialPortInfo(const QString &name);
-    ~SerialPortInfo();
+    QSerialPortInfo();
+    QSerialPortInfo(const QSerialPortInfo &other);
+    QSerialPortInfo(const QSerialPort &port);
+    QSerialPortInfo(const QString &name);
+    ~QSerialPortInfo();
 
-    SerialPortInfo& operator=(const SerialPortInfo &other);
-    void swap(SerialPortInfo &other);
+    QSerialPortInfo& operator=(const QSerialPortInfo &other);
+    void swap(QSerialPortInfo &other);
 
     QString portName() const;
     QString systemLocation() const;
@@ -79,13 +79,13 @@ public:
     bool isValid() const;
 
     static QList<qint32> standardBaudRates();
-    static QList<SerialPortInfo> availablePorts();
+    static QList<QSerialPortInfo> availablePorts();
 
 private:
-    QScopedPointer<SerialPortInfoPrivate, SerialInfoPrivateDeleter> d_ptr;
+    QScopedPointer<QSerialPortInfoPrivate, QSerialInfoPrivateDeleter> d_ptr;
 };
 
-inline bool SerialPortInfo::isNull() const
+inline bool QSerialPortInfo::isNull() const
 { return !d_ptr; }
 
 QT_END_NAMESPACE_SERIALPORT
diff --git a/src/serialport/serialportinfo_mac.cpp b/src/serialport/serialportinfo_mac.cpp
index 91cfefd..71c68d7 100644
--- a/src/serialport/serialportinfo_mac.cpp
+++ b/src/serialport/serialportinfo_mac.cpp
@@ -61,9 +61,9 @@ QT_BEGIN_NAMESPACE_SERIALPORT
 
 enum { MATCHING_PROPERTIES_COUNT = 6 };
 
-QList<SerialPortInfo> SerialPortInfo::availablePorts()
+QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
 
     int matchingPropertiesCounter = 0;
 
@@ -187,7 +187,7 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
         // Convert from MacOSX-specific properties to Qt4-specific.
         if (matchingPropertiesCounter > 0) {
 
-            SerialPortInfo info;
+            QSerialPortInfo info;
             QByteArray buffer(MAXPATHLEN, 0);
 
             if (device) {
diff --git a/src/serialport/serialportinfo_p.h b/src/serialport/serialportinfo_p.h
index 9fe6447..d315a8d 100644
--- a/src/serialport/serialportinfo_p.h
+++ b/src/serialport/serialportinfo_p.h
@@ -41,8 +41,8 @@
 **
 ****************************************************************************/
 
-#ifndef SERIALPORTINFO_P_H
-#define SERIALPORTINFO_P_H
+#ifndef QSERIALPORTINFO_P_H
+#define QSERIALPORTINFO_P_H
 
 #include "serialport-global.h"
 
@@ -50,11 +50,11 @@
 
 QT_BEGIN_NAMESPACE_SERIALPORT
 
-class SerialPortInfoPrivate
+class QSerialPortInfoPrivate
 {
 public:
-    SerialPortInfoPrivate() {}
-    ~SerialPortInfoPrivate() {}
+    QSerialPortInfoPrivate() {}
+    ~QSerialPortInfoPrivate() {}
 
     QString portName;
     QString device;
@@ -64,14 +64,14 @@ public:
     QString productIdentifier;
 };
 
-class SerialInfoPrivateDeleter
+class QSerialInfoPrivateDeleter
 {
 public:
-    static void cleanup(SerialPortInfoPrivate *p) {
+    static void cleanup(QSerialPortInfoPrivate *p) {
         delete p;
     }
 };
 
 QT_END_NAMESPACE_SERIALPORT
 
-#endif // SERIALPORTINFO_P_H
+#endif // QSERIALPORTINFO_P_H
diff --git a/src/serialport/serialportinfo_symbian.cpp b/src/serialport/serialportinfo_symbian.cpp
index e505f34..4fedb9f 100644
--- a/src/serialport/serialportinfo_symbian.cpp
+++ b/src/serialport/serialportinfo_symbian.cpp
@@ -99,9 +99,9 @@ static bool loadDevices()
     return true;
 }
 
-QList<SerialPortInfo> SerialPortInfo::availablePorts()
+QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
 
     if (!loadDevices())
         return ports;
@@ -123,7 +123,7 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
             //
             for (quint32 i = nativeInfo.iLowUnit; i < nativeInfo.iHighUnit + 1; ++i) {
 
-                SerialPortInfo info; // My (desired) info class.
+                QSerialPortInfo info; // My (desired) info class.
 
                 info.d_ptr->device = s
                         .arg(QString::fromUtf16(nativeInfo.iName.Ptr(), nativeInfo.iName.Length()))
@@ -146,7 +146,7 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
             //
             for (quint32 i = nativeInfo.iLowUnit; i < nativeInfo.iHighUnit + 1; ++i) {
 
-                SerialPortInfo info; // My (desired) info class.
+                QSerialPortInfo info; // My (desired) info class.
 
                 info.d_ptr->device = s
                         .arg(QString::fromUtf16(nativeInfo.iName.Ptr(), nativeInfo.iName.Length()))
@@ -169,7 +169,7 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
             //
             for (quint32 i = nativeInfo.iLowUnit; i < nativeInfo.iHighUnit + 1; ++i) {
 
-                SerialPortInfo info; // My (desired) info class.
+                QSerialPortInfo info; // My (desired) info class.
 
                 info.d_ptr->device = s
                         .arg(QString::fromUtf16(nativeInfo.iName.Ptr(), nativeInfo.iName.Length()))
@@ -192,12 +192,12 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
             //
             for (quint32 i = nativeInfo.iLowUnit; i < nativeInfo.iHighUnit + 1; ++i) {
 
-                SerialPortInfo info; // My (desired) info class.
+                QSerialPortInfo info; // My (desired) info class.
 
                 info.d_ptr->device = s
                         .arg(QString::fromUtf16(nativeInfo.iName.Ptr(), nativeInfo.iName.Length()))
                         .arg(i);
-                info.d_ptr->portName = SerialPortPrivate::portNameFromSystemLocation(info.d_ptr->device);
+                info.d_ptr->portName = QSerialPortPrivate::portNameFromSystemLocation(info.d_ptr->device);
                 info.d_ptr->description =
                         QString::fromUtf16(nativeInfo.iDescription.Ptr(), nativeInfo.iDescription.Length());
                 info.d_ptr->manufacturer = QString(QObject::tr("Unknown."));
@@ -209,12 +209,12 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
     return ports;
 }
 
-QList<qint32> SerialPortInfo::standardRates()
+QList<qint32> QSerialPortInfo::standardRates()
 {
-    return SerialPortPrivate::standardRates();
+    return QSerialPortPrivate::standardRates();
 }
 
-bool SerialPortInfo::isBusy() const
+bool QSerialPortInfo::isBusy() const
 {
     if (!loadDevices())
         return false;
@@ -232,7 +232,7 @@ bool SerialPortInfo::isBusy() const
     return r == KErrLocked;
 }
 
-bool SerialPortInfo::isValid() const
+bool QSerialPortInfo::isValid() const
 {
     if (!loadDevices())
         return false;
diff --git a/src/serialport/serialportinfo_unix.cpp b/src/serialport/serialportinfo_unix.cpp
index 904e244..8efe529 100644
--- a/src/serialport/serialportinfo_unix.cpp
+++ b/src/serialport/serialportinfo_unix.cpp
@@ -100,9 +100,9 @@ inline QStringList& filtersOfDevices()
 
 #endif
 
-QList<SerialPortInfo> SerialPortInfo::availablePorts()
+QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
 
 #if defined (Q_OS_LINUX) && defined (HAVE_LIBUDEV)
 
@@ -129,7 +129,7 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
 
                 if (dev) {
 
-                    SerialPortInfo info;
+                    QSerialPortInfo info;
 
                     info.d_ptr->device =
                             QLatin1String(::udev_device_get_devnode(dev));
@@ -221,10 +221,10 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
             if (!foundDevices.contains(s)) {
                 foundDevices.append(s);
 
-                SerialPortInfo info;
+                QSerialPortInfo info;
 
                 info.d_ptr->device = s;
-                info.d_ptr->portName = SerialPortPrivate::portNameFromSystemLocation(s);
+                info.d_ptr->portName = QSerialPortPrivate::portNameFromSystemLocation(s);
 
                 // Get description, manufacturer, vendor identifier, product
                 // identifier are not supported.
@@ -244,18 +244,18 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
 
 // common part
 
-QList<qint32> SerialPortInfo::standardBaudRates()
+QList<qint32> QSerialPortInfo::standardBaudRates()
 {
-    return SerialPortPrivate::standardBaudRates();
+    return QSerialPortPrivate::standardBaudRates();
 }
 
-bool SerialPortInfo::isBusy() const
+bool QSerialPortInfo::isBusy() const
 {
     bool currentPid = false;
     return TtyLocker::isLocked(portName().toLocal8Bit().constData(), &currentPid);
 }
 
-bool SerialPortInfo::isValid() const
+bool QSerialPortInfo::isValid() const
 {
     QFile f(systemLocation());
     return f.exists();
diff --git a/src/serialport/serialportinfo_win.cpp b/src/serialport/serialportinfo_win.cpp
index 8eae54d..ab96229 100644
--- a/src/serialport/serialportinfo_win.cpp
+++ b/src/serialport/serialportinfo_win.cpp
@@ -140,9 +140,9 @@ static QString devicePortName(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInf
     return QString::fromWCharArray(((const wchar_t *)data.constData()));
 }
 
-QList<SerialPortInfo> SerialPortInfo::availablePorts()
+QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
     static const int guidCount = sizeof(guidsArray)/sizeof(guidsArray[0]);
 
     for (int i = 0; i < guidCount; ++i) {
@@ -156,14 +156,14 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
 
         DWORD index = 0;
         while (::SetupDiEnumDeviceInfo(deviceInfoSet, index++, &deviceInfoData)) {
-            SerialPortInfo info;
+            QSerialPortInfo info;
 
             QString s = devicePortName(deviceInfoSet, &deviceInfoData);
             if (s.isEmpty() || s.contains(QLatin1String("LPT")))
                 continue;
 
             info.d_ptr->portName = s;
-            info.d_ptr->device = SerialPortPrivate::portNameToSystemLocation(s);
+            info.d_ptr->device = QSerialPortPrivate::portNameToSystemLocation(s);
             info.d_ptr->description =
                     deviceRegistryProperty(deviceInfoSet, &deviceInfoData, SPDRP_DEVICEDESC).toString();
             info.d_ptr->manufacturer =
@@ -184,12 +184,12 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
 
 // common part
 
-QList<qint32> SerialPortInfo::standardBaudRates()
+QList<qint32> QSerialPortInfo::standardBaudRates()
 {
-    return SerialPortPrivate::standardBaudRates();
+    return QSerialPortPrivate::standardBaudRates();
 }
 
-bool SerialPortInfo::isBusy() const
+bool QSerialPortInfo::isBusy() const
 {
     const HANDLE descriptor = ::CreateFile(reinterpret_cast<const wchar_t*>(systemLocation().utf16()),
                                            GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
@@ -203,7 +203,7 @@ bool SerialPortInfo::isBusy() const
     return false;
 }
 
-bool SerialPortInfo::isValid() const
+bool QSerialPortInfo::isValid() const
 {
     const HANDLE descriptor = ::CreateFile(reinterpret_cast<const wchar_t*>(systemLocation().utf16()),
                                            GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
diff --git a/src/serialport/serialportinfo_wince.cpp b/src/serialport/serialportinfo_wince.cpp
index aec35b0..7a20245 100644
--- a/src/serialport/serialportinfo_wince.cpp
+++ b/src/serialport/serialportinfo_wince.cpp
@@ -101,9 +101,9 @@ static QString findDescription(HKEY parentKeyHandle, const QString &subKey)
     return result;
 }
 
-QList<SerialPortInfo> SerialPortInfo::availablePorts()
+QList<QSerialPortInfo> QSerialPortInfo::availablePorts()
 {
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
 
     DEVMGR_DEVICE_INFORMATION di;
     di.dwSize = sizeof(di);
@@ -112,9 +112,9 @@ QList<SerialPortInfo> SerialPortInfo::availablePorts()
                                              &di);
     if (hSearch != INVALID_HANDLE_VALUE) {
         do {
-            SerialPortInfo info;
+            QSerialPortInfo info;
             info.d_ptr->device = QString::fromWCharArray(di.szLegacyName);
-            info.d_ptr->portName = SerialPortPrivate::portNameFromSystemLocation(info.d_ptr->device);
+            info.d_ptr->portName = QSerialPortPrivate::portNameFromSystemLocation(info.d_ptr->device);
             info.d_ptr->description = findDescription(HKEY_LOCAL_MACHINE,
                                                       QString::fromWCharArray(di.szDeviceKey));
 
diff --git a/tests/manual/serialport/tst_serialport.cpp b/tests/manual/serialport/tst_serialport.cpp
index 8b306b2..f4ce395 100644
--- a/tests/manual/serialport/tst_serialport.cpp
+++ b/tests/manual/serialport/tst_serialport.cpp
@@ -47,7 +47,7 @@
 
 QT_USE_NAMESPACE_SERIALPORT
 
-class tst_SerialPort : public QObject
+class tst_QSerialPort : public QObject
 {
     Q_OBJECT
 
@@ -61,12 +61,12 @@ private slots:
     void flowControl();
 
 private:
-    QList<SerialPortInfo> ports;
+    QList<QSerialPortInfo> ports;
 };
 
-void tst_SerialPort::initTestCase()
+void tst_QSerialPort::initTestCase()
 {
-    ports = SerialPortInfo::availablePorts();
+    ports = QSerialPortInfo::availablePorts();
 
     if (ports.isEmpty()) {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
@@ -77,14 +77,14 @@ void tst_SerialPort::initTestCase()
     }
 }
 
-void tst_SerialPort::open()
+void tst_QSerialPort::open()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
         if (info.isBusy())
             continue;
 
-        SerialPort object1;
+        QSerialPort object1;
 
         // Try open and check access to port by Info
         object1.setPort(info);
@@ -112,109 +112,109 @@ void tst_SerialPort::open()
     }
 }
 
-void tst_SerialPort::baudRate()
+void tst_QSerialPort::baudRate()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
-        SerialPort object1;
+        QSerialPort object1;
         object1.setPort(info.portName());
         QCOMPARE(object1.open(QIODevice::ReadWrite), true);
 
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud1200), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud1200));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud2400), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud2400));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud4800), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud4800));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud9600), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud9600));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud19200), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud19200));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud38400), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud38400));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud57600), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud57600));
-        QCOMPARE(object1.setBaudRate(SerialPort::Baud115200), true);
-        QCOMPARE(object1.baudRate(), static_cast<qint32>(SerialPort::Baud115200));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud1200), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud1200));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud2400), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud2400));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud4800), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud4800));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud9600), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud9600));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud19200), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud19200));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud38400), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud38400));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud57600), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud57600));
+        QCOMPARE(object1.setBaudRate(QSerialPort::Baud115200), true);
+        QCOMPARE(object1.baudRate(), static_cast<qint32>(QSerialPort::Baud115200));
 
         object1.close();
     }
 }
 
-void tst_SerialPort::dataBits()
+void tst_QSerialPort::dataBits()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
-        SerialPort object1;
+        QSerialPort object1;
         object1.setPort(info.portName());
         QCOMPARE(object1.open(QIODevice::ReadWrite), true);
 
-        QCOMPARE(object1.setDataBits(SerialPort::Data8), true);
-        QCOMPARE(object1.dataBits(), SerialPort::Data8);
+        QCOMPARE(object1.setDataBits(QSerialPort::Data8), true);
+        QCOMPARE(object1.dataBits(), QSerialPort::Data8);
 
         object1.close();
     }
 }
 
-void tst_SerialPort::parity()
+void tst_QSerialPort::parity()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
-        SerialPort object1;
+        QSerialPort object1;
         object1.setPort(info.portName());
         QCOMPARE(object1.open(QIODevice::ReadWrite), true);
 
-        QCOMPARE(object1.setParity(SerialPort::NoParity), true);
-        QCOMPARE(object1.parity(), SerialPort::NoParity);
-        QCOMPARE(object1.setParity(SerialPort::EvenParity), true);
-        QCOMPARE(object1.parity(), SerialPort::EvenParity);
-        QCOMPARE(object1.setParity(SerialPort::OddParity), true);
-        QCOMPARE(object1.parity(), SerialPort::OddParity);
-        QCOMPARE(object1.setParity(SerialPort::MarkParity), true);
-        QCOMPARE(object1.parity(), SerialPort::MarkParity);
-        QCOMPARE(object1.setParity(SerialPort::SpaceParity), true);
-        QCOMPARE(object1.parity(), SerialPort::SpaceParity);
+        QCOMPARE(object1.setParity(QSerialPort::NoParity), true);
+        QCOMPARE(object1.parity(), QSerialPort::NoParity);
+        QCOMPARE(object1.setParity(QSerialPort::EvenParity), true);
+        QCOMPARE(object1.parity(), QSerialPort::EvenParity);
+        QCOMPARE(object1.setParity(QSerialPort::OddParity), true);
+        QCOMPARE(object1.parity(), QSerialPort::OddParity);
+        QCOMPARE(object1.setParity(QSerialPort::MarkParity), true);
+        QCOMPARE(object1.parity(), QSerialPort::MarkParity);
+        QCOMPARE(object1.setParity(QSerialPort::SpaceParity), true);
+        QCOMPARE(object1.parity(), QSerialPort::SpaceParity);
 
         object1.close();
     }
 }
 
-void tst_SerialPort::stopBits()
+void tst_QSerialPort::stopBits()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
-        SerialPort object1;
+        QSerialPort object1;
         object1.setPort(info.portName());
         QCOMPARE(object1.open(QIODevice::ReadWrite), true);
 
-        QCOMPARE(object1.setStopBits(SerialPort::OneStop), true);
-        QCOMPARE(object1.stopBits(), SerialPort::OneStop);
+        QCOMPARE(object1.setStopBits(QSerialPort::OneStop), true);
+        QCOMPARE(object1.stopBits(), QSerialPort::OneStop);
         // skip 1.5 stop bits
-        QCOMPARE(object1.setStopBits(SerialPort::TwoStop), true);
-        QCOMPARE(object1.stopBits(), SerialPort::TwoStop);
+        QCOMPARE(object1.setStopBits(QSerialPort::TwoStop), true);
+        QCOMPARE(object1.stopBits(), QSerialPort::TwoStop);
 
         object1.close();
     }
 }
 
-void tst_SerialPort::flowControl()
+void tst_QSerialPort::flowControl()
 {
-    foreach (const SerialPortInfo &info, ports) {
+    foreach (const QSerialPortInfo &info, ports) {
 
-        SerialPort object1;
+        QSerialPort object1;
         object1.setPort(info.portName());
         QCOMPARE(object1.open(QIODevice::ReadWrite), true);
 
-        QCOMPARE(object1.setFlowControl(SerialPort::NoFlowControl), true);
-        QCOMPARE(object1.flowControl(), SerialPort::NoFlowControl);
-        QCOMPARE(object1.setFlowControl(SerialPort::HardwareControl), true);
-        QCOMPARE(object1.flowControl(), SerialPort::HardwareControl);
-        QCOMPARE(object1.setFlowControl(SerialPort::SoftwareControl), true);
-        QCOMPARE(object1.flowControl(), SerialPort::SoftwareControl);
+        QCOMPARE(object1.setFlowControl(QSerialPort::NoFlowControl), true);
+        QCOMPARE(object1.flowControl(), QSerialPort::NoFlowControl);
+        QCOMPARE(object1.setFlowControl(QSerialPort::HardwareControl), true);
+        QCOMPARE(object1.flowControl(), QSerialPort::HardwareControl);
+        QCOMPARE(object1.setFlowControl(QSerialPort::SoftwareControl), true);
+        QCOMPARE(object1.flowControl(), QSerialPort::SoftwareControl);
 
         object1.close();
     }
 }
 
-QTEST_MAIN(tst_SerialPort)
+QTEST_MAIN(tst_QSerialPort)
 #include "tst_serialport.moc"
diff --git a/tests/manual/serialportinfo/tst_serialportinfo.cpp b/tests/manual/serialportinfo/tst_serialportinfo.cpp
index 35b06e9..12cb5b6 100644
--- a/tests/manual/serialportinfo/tst_serialportinfo.cpp
+++ b/tests/manual/serialportinfo/tst_serialportinfo.cpp
@@ -47,7 +47,7 @@
 
 QT_USE_NAMESPACE_SERIALPORT
 
-class tst_SerialPortInfo : public QObject
+class tst_QSerialPortInfo : public QObject
 {
     Q_OBJECT
 
@@ -57,23 +57,23 @@ private slots:
     void assignment();
 };
 
-void tst_SerialPortInfo::ports()
+void tst_QSerialPortInfo::ports()
 {
-    QList<SerialPortInfo> list(SerialPortInfo::availablePorts());
+    QList<QSerialPortInfo> list(QSerialPortInfo::availablePorts());
     QCOMPARE(list.isEmpty(), false);
 }
 
-void tst_SerialPortInfo::constructors()
+void tst_QSerialPortInfo::constructors()
 {
     // FIXME
 }
 
-void tst_SerialPortInfo::assignment()
+void tst_QSerialPortInfo::assignment()
 {
-    QList<SerialPortInfo> list(SerialPortInfo::availablePorts());
+    QList<QSerialPortInfo> list(QSerialPortInfo::availablePorts());
 
     for (int c = 0; c < list.size(); ++c) {
-        SerialPortInfo info = list[c];
+        QSerialPortInfo info = list[c];
         QCOMPARE(info.portName(), list[c].portName());
         QCOMPARE(info.systemLocation(), list[c].systemLocation());
         QCOMPARE(info.description(), list[c].description());
@@ -83,5 +83,5 @@ void tst_SerialPortInfo::assignment()
     }
 }
 
-QTEST_MAIN(tst_SerialPortInfo)
+QTEST_MAIN(tst_QSerialPortInfo)
 #include "tst_serialportinfo.moc"