Update qextserialport and build as library

src/3rdparty/qextserialport/.hgignore → src/3rdparty/qextserialport/.gitignore

-syntax: glob
-*.pro.user*
-*.app
-*.moc
-Makefile*
-doc/html/
-debug/
-release/
-qtc-gdbmacros/
-*.rej
-*.orig
-*.obj
-*.swp
-*.dll
-*.exp
-*.ilk
-*.pdb
-*.lib
-moc_*.cpp
-qrc_*.cpp
-*.o
-*.so.*
-*.so
-*.pdb
-ui_*.h
-*~
-.qmake.cache
-lib/*
-*.orig
-*.exe
-*.vcproj
-*.vcproj.*.user
-*.sln
-*.idb
-*.ncb
-*.suo
-examples/enumerator/enumerator
-examples/event/event
-examples/qespta/qespta
-examples/uartassistant/uartassistant
-object_script.*
+syntax: glob
+*.pro.user*
+*.app
+*.moc
+*.prl
+Makefile*
+doc/html/
+*.framework/
+*.xcodeproj/
+debug/
+release/
+qtc-gdbmacros/
+*.rej
+*.orig
+*.obj
+*.swp
+*.dll
+*.exp
+*.ilk
+*.pdb
+*.lib
+Thumbs.db
+moc_*.cpp
+qrc_*.cpp
+*.o
+*.so.*
+*.so
+*.pdb
+ui_*.h
+*~
+.qmake.cache
+extserialport.prf
+lib/*
+*.orig
+*.exe
+*.vcproj
+*.vcproj.*.user
+*_resource.rc
+*.sln
+*.idb
+*.ncb
+*.suo
+examples/enumerator/enumerator
+examples/event/event
+examples/qespta/qespta
+examples/uartassistant/uartassistant
+object_script.*

src/3rdparty/qextserialport/.hgtags

-96e3a424c22cda7bd430736ffe8ec94c02e9d462 REL_0_9
-ecdbd5f836603c25941f6ea7659b271767088cb8 REL_1_1
-f5c8064caf35b35778bd191a2d8aed9e7b1260f4 REL_0_8
-4a0173d282232b56c55962e17aa254917c52c4c0 1.2-beta1

src/3rdparty/qextserialport/ChangeLog

 (Lines beginning with + represent new functionality, * represent changed or
 fixed functionality, - represent removed or deprecated functionality)
 
+Version 1.2 rc (2012 Debao Zhang)
+  * Build-system refactor
+  * Issue 145 : Custom baud support for MacOS
+  * Issue 36  : Fix Devices Notification for Vista
+  * Issue 54 and Issue 108 : Try detect more ports for windows
+  * Issue 139 : Adjust the name of generated library
+  - QextWinEventNotifier has been removed
+
+Version 1.2 beta2 (2012 Debao Zhang)
+  * Issue 124 : implement canReadLine
+  * Issue 122 : make Dtr default to TRUE under Windows.
+  * Issue 127 : fix QObject::MoveToThread brokes SerialPort on Windows
+  * Issue 129 : Add custom baud support for Windows.
+  * Issue 131 : Make sure portName returned by QextSerialEnumerator can be used by QextSerialPort
+  * Issue 134 : Make "make install" really works
+  * Issue 2: device discovery / removal notification on linux (read config_example.pri to figure out how to enable it.)
+
 Version 1.2 beta1 (2012 Debao Zhang)
   * D-pointer and Q_PRIVATE_SLOT are used to moving private members from QextSerialPort to QextSerialPortPrivate
   * qdoc3 instead of doxygen is used for generating documents
   * MIT license header add to all sources files
   + add a helper class QextWinEventNotifier for windows user, when user's SDK doesnot contain Qt's private files, this class will be auto selected.
-  + Support platform custom baudrate. Macros such as B230400 / B460800 can be used directly if you OS support it. 
 
 Version 1.2win-alpha (2007 Michal Policht)
   + Added QextSerialEnumerator pre-alpha. Works under W2k and later versions of Windows.

src/3rdparty/qextserialport/LICENSE

  * Liam Staskawicz,
 
     That works for me - let's call it MIT and go for it :) 
+
+And from [[https://groups.google.com/forum/?fromgroups#!topic/qextserialport/P_5TrNHBICE this other thread]] on the same mailing list:
+
+ * Michal Policht,
+
+    I agree to license.

src/3rdparty/qextserialport/README

             ....
             
 == How to use (2) ==
-
 It's very easy to compile QextSerialPort directly into your application
-(see above section), however, we would prefer to use it as a static or
- shared library.
-
- * Download the source code, and put it in any location you like.
-
-           |-- yourpath\
-           |     |-- qextserialport\
-           |     |
-
- * Create a config.pri file, and put into qextserialport's directory.
-
-           |-- yourpath\
-           |     |-- qextserialport\
-           |     |     |-- config.pri
-           
-   * Contents of config_example.pri
-  
-           # uncomment the following line if you want to use qesp as library
-           # QEXTSERIALPORT_LIBRARY = yes
-
-           # uncomment the following line too if you want to use it as static library
-           # QEXTSERIALPORT_STATIC = yes
-
- * Goto qextserialport/buildlib, and run following command to generate library.
-
-           qmake
-           make (or nmake)
-
- * Add following line to your qmake project file. Enjoy it!
-
-           include(pathToQextserialport/src/qextserialport.pri)
-
-== How to use (3) ==
-
-Someone complains that, I want to used !QextSerialPort as a shared libaray, but
-I don't want to add the {{{include(***.pri)}}} to my project file. Otherwise,
-all the source files of !QextSerialPort will be shown in Qt Creator, which is
-very annoying.
-
-Ok, let's go!
+(see above section), however, we would prefer to use it as a shared library.
 
  * Download the source code, and put it in any location you like.
 
- * Goto qextserialport/buildlib, and run following command to generate library. (Yes, config.pri is not needed.)
+ * Run following command to generate library. 
 
           qmake
           make (or nmake)
+          sudo make install (or nmake install)
 
- * Add following lines to your .pro file. And you need to specify the path to the lib and headers. Then Enjoy it!
-
-          # Specify lib and headers path if they are not in standard locations.
-          # Otherwise, your can ignore this.
-          unix{
-             QEXTSERIALPORT_LIBDIR = #path_to_qextserialport_lib
-             QEXTSERIALPORT_INCDIR = #path_to_qextserialport_headers
-          }else{
-             QEXTSERIALPORT_LIBDIR = #path_to_qextserialport_lib
-             QEXTSERIALPORT_INCDIR = #path_to_qextserialport_headers
-          }
-
-          SAVE_TEMPLATE = $$TEMPLATE
-          TEMPLATE = fakelib
-          QEXTSERIALPORT_LIBNAME = $$qtLibraryTarget(qextserialport-1.2)
-          TEMPLATE = $$SAVE_TEMPLATE
-
-          INCLUDEPATH += $$QEXTSERIALPORT_INCDIR
-          LIBS += -L$$QEXTSERIALPORT_LIBDIR -l$$QEXTSERIALPORT_LIBNAME
-          DEFINES += QEXTSERIALPORT_USING_SHARED
-
-          unix:QMAKE_RPATHDIR += $$QEXTSERIALPORT_LIBDIR
-
- * Oh, this file looks a bit complicated, as we need cross-platform. If you don't care cross-platform. It will be very simple :-) , for example
-      
-          INCLUDEPATH += /home/xxxx/download/qextserialport/src
-          LIBS += /home/xxxx/download/qextserialport/lib/libqextsrialport-1.2.so
-          DEFINES += QEXTSERIALPORT_USING_SHARED
-
- * Note:
-  * If you do not want to add such lines to each of your projects. This is another solution too.
-  * Create a new file called *extserialport.prf* , then add above lines to this new file.
-  * Put this .prf file to one of feature paths, such as
-          
-          $QTDIR\mkspecs\features\
-          
-  * Add the following line to your .pro file. Enjoy it!
+ * Add following line to your project's file
 
           CONFIG += extserialport
 
-== Build (optional) ==
+ * Using QextSerialPort in your code. Enjoy it!
 
- * Run qmake from the toplevel directory.(If your has create a config.pri file properly, this will generate the library, and then all examples will use the library. Otherwise, qextserialport will be directly compiled into the examples)
+            #include "qextserialport.h"
+            ....
+            QextSerialPort * port = new QextSerialPort();
+            ....
 
-           qmake (or qmake -r)
-           make (or nmake)
+== Build Documents ==
+ * Run
+           qmake
+           make docs
 
- * Run qdoc3 from the doc directory.
+ * Note: More information can be found in doc/readme.txt
 
-           qdoc3 qextserialport.qdocconf
+== Build examples ==
+ * Goto examples directory, then run
+           qmake (or qmake -r)
+           make (or nmake)
 

src/3rdparty/qextserialport/buildlib/buildlib.pro

-TEMPLATE=lib
-CONFIG += qt qextserialport-buildlib
-# Include .pri file before using "qextserialport-static"
-# and after CONFIG += "qextserialport-buildlib"
-include(../src/qextserialport.pri)
-qextserialport-static:CONFIG += static
-else:CONFIG += dll
-mac:CONFIG += absolute_library_soname
-win32|mac:!wince*:!win32-msvc:!macx-xcode:CONFIG += debug_and_release build_all
-TARGET = $$QEXTSERIALPORT_LIBNAME
-DESTDIR = $$QEXTSERIALPORT_LIBDIR
-win32:!qextserialport-static{
-    DLLDESTDIR = $$[QT_INSTALL_BINS]
-    QMAKE_DISTCLEAN += $$[QT_INSTALL_BINS]\\$${QEXTSERIALPORT_LIBNAME}.dll
-}
-target.path = $$DESTDIR
-INSTALLS += target

src/3rdparty/qextserialport/common.pri

-infile(config.pri, QEXTSERIALPORT_LIBRARY, yes): CONFIG += qextserialport-library
-qextserialport-library{
-    infile(config.pri, QEXTSERIALPORT_STATIC, yes): CONFIG += qextserialport-static
-}
-# Though maybe you have been fimiliar with "TEMPLATE += fakelib" and "TEMPLATE -= fakelib",
-# but it don't work when you using "qmake -tp XXX". So I use another variable Here.
-SAVE_TEMPLATE = $$TEMPLATE
-TEMPLATE = fakelib
-contains(QT_VERSION, ^5\\..*\\..*) {
-    #different name for Qt4 and Qt5
-    QEXTSERIALPORT_LIBNAME = $$qtLibraryTarget(QtExtSerialPort-1.2)
-} else {
-    QEXTSERIALPORT_LIBNAME = $$qtLibraryTarget(qextserialport-1.2)
-}
-TEMPLATE = $$SAVE_TEMPLATE
-QEXTSERIALPORT_LIBDIR = $$PWD/lib
-unix:qextserialport-library:!qextserialport-buildlib:QMAKE_RPATHDIR += $$QEXTSERIALPORT_LIBDIR

src/3rdparty/qextserialport/config_example.pri

-# This is an example config.pri for building and using qextserialport.
-# 
-# When using the qextserialport, all you need is to add following line
-# in your .pro file:
-#    include(pathToQextserialport/src/qextserialport.pri)
-#
-# uncomment the following line if you want to use qextserialport as library
-# QEXTSERIALPORT_LIBRARY = yes
-
-# uncomment the following line too if you want to use it as static library
-# QEXTSERIALPORT_STATIC = yes

src/3rdparty/qextserialport/doc/index.qdoc

       \endlist
     
     \section1 Getting Started
-      The package contains a qextserialport.pri file that allows you to integrate the 
-      component into programs that use qmake for the build step.
 
-      All you need is adding following line to your qmake's project file:
+
+    \section2 Usage(1): Source Code Only
+
+ The package contains a qextserialport.pri file that allows you to integrate the component into programs that use qmake for the build step.
+
+      Download the source code.
+      Put the source code in any directory you like. For example, 3rdparty:
+
+      \code
+       |-- project.pro
+       |-- ....
+       |-- 3rdparty\
+       |     |-- qextserialport\
+       |     |
+      \endcode
+
+      Add following line to your qmake project file:
       \code
       include(pathToPri/qextserialport.pri)
       \endcode
       }
       \endcode
 
-    \section2 Using QexSerialPort as library
+    \section2 Usage(2): shared library
       Although QextSerialPort can be directly compiled into your application, You may prefer
       to use QextSerailPort as an library, which is very easy too.
 
-      1. Write a config.pri file.(read config_example.pri for reference):
+     1. Download the source code, and put it in any location you like.
+    
+     2. Goto the top level directory ,run following command to generate library.
+    
+          \code
+          qmake
+          sudo make install (or nmake install)
+          \endcode
+    
+     3. Add following line to your project's file
+    
+          \code
+          CONFIG += extserialport
+          \endcode
+    
+     4. Using QextSerialPort in your code. Enjoy it!
+    
+          \code
+          #include "qextserialport.h"
+          ....
+          QextSerialPort * port = new QextSerialPort();
+          ....
+          \endcode
+
+    \section2 Usage(3): Static library
 
-      \list
-        \o shared library
-        \o static library
-      \endlist
+        Someone prefer to use QextSerailPort as static library.
 
-      2. Changed to subdirectory 'buildlib', run
-      \code
-      qmake
-      make
-      \endcode
-      shared or static library will be generated.
+        Open the project file: qextserialport.pro, add uncomment follow line
+
+          \code
+           # CONFIG += qesp_static
+          \endcode
+
+        Then follow the same steps as shared library
+
+          \code
+           qmake
+           sudo make install
+          \endcode
+
+        The static library, the header files, and the feature file will be installed to your system.
+
+        Add following line to your qmake's project file:
+
+          \code
+          CONFIG += extserialport
+          \endcode
+    
+      \section1 Platform Special
+
+      \section2 For MacX: Build as framework
+
+      Open the project file: *qextserialport.pro*, and uncomment follow line
+
+          \code
+           # CONFIG += qesp_mac_framework
+          \endcode
+
+      Then follow the same steps as shared library, Goto the top level directory , and run
+
+          \code
+           qmake
+           sudo make install
+          \endcode
+ 
+      The framework which includes libraries and the header files, and the feature file will be installed to your system.
+
+      Add following line to your qmake's project file:
+
+          \code
+           CONFIG += extserialport
+          \endcode
+
+      \section2 For Linux: Enable udev
+
+       Open the project file: *qextserialport.pro*, uncomment follow line
+
+          \code
+           #linux*:CONFIG += qesp_linux_udev
+          \endcode
+
+       Note, If you are using the usage(1), Add following line before include the qextserialport.pri file. 
+          \code
+           CONFIG += qesp_linux_udev
+          \endcode
 
-      3.  Add following line to your qmake project file:
-      \code
-      include(pathToPri/qextserialport.pri)
-      \endcode
 
      \section2 Build documents
-      Run qdoc3 from the doc directory.
       \code
-        qdoc3 qextserialport.qdocconf
+        make docs
       \endcode
-      Note: qdoc3 has been renamed to qdoc under Qt5.
 
     \section1 Examples
       \list
       \o \l examples/uartassistant
       \endlist
 
-     \section2 Build examples
-      Run following commands at toplevel directory
-      \code
-      qmake
-      make
-      \endcode
-
-      or simply open the qextserialport.pro using Qt Creator.
-
     \section1 Resources
         \section2  Nokia(Trolltech)
         \list

src/3rdparty/qextserialport/examples/event/PortListener.cpp

 #include "PortListener.h"
 #include <QtDebug>
 
-PortListener::PortListener(const QString & portName)
+PortListener::PortListener(const QString &portName)
 {
     qDebug() << "hi there";
     this->port = new QextSerialPort(portName, QextSerialPort::EventDriven);

src/3rdparty/qextserialport/examples/event/PortListener.h

 {
 Q_OBJECT
 public:
-    PortListener(const QString & portName);
+    PortListener(const QString &portName);
 
 private:
     QextSerialPort *port;

src/3rdparty/qextserialport/examples/qespta/MainWindow.cpp

 MainWindow::MainWindow()
 {
     //central widget
-	QespTest* qespTest = new QespTest();
+    QespTest *qespTest = new QespTest();
     setCentralWidget(qespTest);
-	//bottom dock widget
-	MessageWindow* msgWindow = new MessageWindow();
-	addDockWidget(Qt::BottomDockWidgetArea, msgWindow);
+    //bottom dock widget
+    MessageWindow *msgWindow = new MessageWindow();
+    addDockWidget(Qt::BottomDockWidgetArea, msgWindow);
 
-	createActions();
-	createMenus();
+    createActions();
+    createMenus();
 
     setWindowTitle(tr("QextSerialPort Test Application"));
 }
 void MainWindow::about()
 {
     QMessageBox::about(this, tr("About "),
-            tr("<B>""</B><BR>"
-				"author: Michal Policht<br>"
-                "<a href='mailto:xpolik@users.sourceforge.net'>xpolik@users.sourceforge.net</a>"));
+                       tr("<B>""</B><BR>"
+                          "author: Michal Policht<br>"
+                          "<a href='mailto:xpolik@users.sourceforge.net'>xpolik@users.sourceforge.net</a>"));
 }
 
 void MainWindow::createActions()
 {
-	//File actions
-	exitAct = new QAction(tr("E&xit"), this);
-	exitAct->setShortcut(tr("CTRL+D"));
-	exitAct->setStatusTip(tr("Exit the application"));
-	connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
-	
-	//Help actions
-	aboutAct = new QAction(tr("&About"), this);
-	aboutAct->setShortcut(tr("CTRL+A"));
-	aboutAct->setStatusTip(tr("About application"));
-	connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
+    //File actions
+    exitAct = new QAction(tr("E&xit"), this);
+    exitAct->setShortcut(tr("CTRL+D"));
+    exitAct->setStatusTip(tr("Exit the application"));
+    connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
+
+    //Help actions
+    aboutAct = new QAction(tr("&About"), this);
+    aboutAct->setShortcut(tr("CTRL+A"));
+    aboutAct->setStatusTip(tr("About application"));
+    connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
 }
 
 void MainWindow::createMenus()
 {
-	fileMenu = menuBar()->addMenu(tr("&File"));
-	fileMenu->addAction(exitAct);
+    fileMenu = menuBar()->addMenu(tr("&File"));
+    fileMenu->addAction(exitAct);
 
-	helpMenu = menuBar()->addMenu(tr("&Help"));
-	helpMenu->addAction(aboutAct);
+    helpMenu = menuBar()->addMenu(tr("&Help"));
+    helpMenu->addAction(aboutAct);
 }
 

src/3rdparty/qextserialport/examples/qespta/MainWindow.h

 
 class MainWindow : public QMainWindow
 {
-	Q_OBJECT
+    Q_OBJECT
 
-	QMenu *fileMenu;
+    QMenu *fileMenu;
     QAction *exitAct;
-	QMenu *helpMenu;
+    QMenu *helpMenu;
     QAction *aboutAct;
-	
+
 private:
     void createMenus();
     void createActions();

src/3rdparty/qextserialport/examples/qespta/MessageWindow.cpp

 #include <QCoreApplication>
 #include <QMutexLocker>
 
-const char* MessageWindow::WINDOW_TITLE = "Message Window";
-MessageWindow* MessageWindow::MsgHandler = NULL;
+const char *MessageWindow::WINDOW_TITLE = "Message Window";
+MessageWindow *MessageWindow::MsgHandler = NULL;
 
-MessageWindow::MessageWindow(QWidget* parent, Qt::WFlags flags) 
-	: QDockWidget(parent, flags),
-		msgTextEdit(this)
+MessageWindow::MessageWindow(QWidget *parent, Qt::WindowFlags flags)
+    : QDockWidget(parent, flags),
+      msgTextEdit(this)
 {
-	setWindowTitle(tr(WINDOW_TITLE));
-	msgTextEdit.setReadOnly(true);
-	setWidget(&msgTextEdit);
+    setWindowTitle(tr(WINDOW_TITLE));
+    msgTextEdit.setReadOnly(true);
+    setWidget(&msgTextEdit);
 
-	MessageWindow::MsgHandler = this;
+    MessageWindow::MsgHandler = this;
 }
 
 //static
 QString MessageWindow::QtMsgToQString(QtMsgType type, const char *msg)
 {
-	switch (type) {
-		case QtDebugMsg:
-			return QLatin1String("Debug: ")+QLatin1String(msg);
-		case QtWarningMsg:
-			return QLatin1String("Warning: ")+QLatin1String(msg);
-		case QtCriticalMsg:
-			return QLatin1String("Critical: ")+QLatin1String(msg);
-		case QtFatalMsg:
-			return QLatin1String("Fatal: ")+QLatin1String(msg);
-		default:
-			return QLatin1String("Unrecognized message type: ")+QLatin1String(msg);
-	}
+    switch (type) {
+    case QtDebugMsg:
+        return QLatin1String("Debug: ")+QLatin1String(msg);
+    case QtWarningMsg:
+        return QLatin1String("Warning: ")+QLatin1String(msg);
+    case QtCriticalMsg:
+        return QLatin1String("Critical: ")+QLatin1String(msg);
+    case QtFatalMsg:
+        return QLatin1String("Fatal: ")+QLatin1String(msg);
+    default:
+        return QLatin1String("Unrecognized message type: ")+QLatin1String(msg);
+    }
 }
 
 //static
-void MessageWindow::AppendMsgWrapper(QtMsgType type, const char* msg)
+void MessageWindow::AppendMsgWrapper(QtMsgType type, const char *msg)
 {
-	static QMutex mutex;
-	QMutexLocker locker(&mutex);
-	
-	if (MessageWindow::MsgHandler != NULL)
-		return MessageWindow::MsgHandler->postMsgEvent(type, msg);
-	else
+    static QMutex mutex;
+    QMutexLocker locker(&mutex);
+
+    if (MessageWindow::MsgHandler != NULL)
+        return MessageWindow::MsgHandler->postMsgEvent(type, msg);
+    else
         fprintf(stderr, "%s", MessageWindow::QtMsgToQString(type, msg).toLatin1().data());
 }
 
-void MessageWindow::customEvent(QEvent* event)
+#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
+void MessageWindow::AppendMsgWrapper(QtMsgType type, const QMessageLogContext & /*context*/, const QString &msg)
+{
+    AppendMsgWrapper(type, msg.toLatin1().data());
+}
+#endif
+
+void MessageWindow::customEvent(QEvent *event)
 {
-	if (static_cast<MessageWindow::EventType>(event->type()) == MessageWindow::MessageEventType)
-		msgTextEdit.append(dynamic_cast<MessageEvent* >(event)->msg);
+    if (static_cast<MessageWindow::EventType>(event->type()) == MessageWindow::MessageEventType)
+        msgTextEdit.append(dynamic_cast<MessageEvent *>(event)->msg);
 }
 
-void MessageWindow::postMsgEvent(QtMsgType type, const char* msg)
+void MessageWindow::postMsgEvent(QtMsgType type, const char *msg)
 {
-	QString qmsg = MessageWindow::QtMsgToQString(type, msg);
-	switch (type) {
-		case QtDebugMsg:
-			break;
-		case QtWarningMsg:
-			qmsg.prepend(QLatin1String("<FONT color=\"#FF0000\">"));
-			qmsg.append(QLatin1String("</FONT>"));
-			break;
-		case QtCriticalMsg:
-			if (QMessageBox::critical(this, QLatin1String("Critical Error"), qmsg,
-					QMessageBox::Ignore,
-					QMessageBox::Abort,
-					QMessageBox::NoButton) == QMessageBox::Abort)
-				abort(); // core dump
-			qmsg.prepend(QLatin1String("<B><FONT color=\"#FF0000\">"));
-			qmsg.append(QLatin1String("</FONT></B>"));
-			break;
-		case QtFatalMsg:
-			QMessageBox::critical(this, QLatin1String("Fatal Error"), qmsg, QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
-			abort(); // deliberately core dump
-	}
-	//it's impossible to change GUI directly from thread other than the main thread 
-	//so post message encapsulated by MessageEvent to the main thread's event queue
-	QCoreApplication::postEvent(this, new MessageEvent(qmsg));
+    QString qmsg = MessageWindow::QtMsgToQString(type, msg);
+    switch (type) {
+    case QtDebugMsg:
+        break;
+    case QtWarningMsg:
+        qmsg.prepend(QLatin1String("<FONT color=\"#FF0000\">"));
+        qmsg.append(QLatin1String("</FONT>"));
+        break;
+    case QtCriticalMsg:
+        if (QMessageBox::critical(this, QLatin1String("Critical Error"), qmsg,
+                                  QMessageBox::Ignore,
+                                  QMessageBox::Abort,
+                                  QMessageBox::NoButton) == QMessageBox::Abort)
+            abort(); // core dump
+        qmsg.prepend(QLatin1String("<B><FONT color=\"#FF0000\">"));
+        qmsg.append(QLatin1String("</FONT></B>"));
+        break;
+    case QtFatalMsg:
+        QMessageBox::critical(this, QLatin1String("Fatal Error"), qmsg, QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
+        abort(); // deliberately core dump
+    }
+    //it's impossible to change GUI directly from thread other than the main thread
+    //so post message encapsulated by MessageEvent to the main thread's event queue
+    QCoreApplication::postEvent(this, new MessageEvent(qmsg));
 }
 
-MessageEvent::MessageEvent(QString & msg):
-	QEvent(static_cast<QEvent::Type>(MessageWindow::MessageEventType))
+MessageEvent::MessageEvent(QString &msg):
+    QEvent(static_cast<QEvent::Type>(MessageWindow::MessageEventType))
 {
-	this->msg = msg;
+    this->msg = msg;
 }

src/3rdparty/qextserialport/examples/qespta/MessageWindow.h

  */
 class MessageWindow: public QDockWidget
 {
-	Q_OBJECT
+    Q_OBJECT
 
-	QTextEdit msgTextEdit;				///< Main widget.
-	static MessageWindow* MsgHandler;	///< Set in constructor.
-	static const char* WINDOW_TITLE; 	///< Window title.
+    QTextEdit msgTextEdit;              ///< Main widget.
+    static MessageWindow *MsgHandler;   ///< Set in constructor.
+    static const char *WINDOW_TITLE;    ///< Window title.
 
-	private:
-		static QString QtMsgToQString(QtMsgType type, const char *msg);
-	
-	protected:
-		/**
-		 * Handle custom events. MessageWindow hadles custom events listed in
-		 * EventType enum.
-		 */
-		virtual void customEvent(QEvent* event);
-		
-	public:
-        enum EventType {MessageEventType = QEvent::User};	///< Custom event types.
-		
-		/**
-		 * Default constructor.
-		 * 	@param parent parent widget.
-		 * 	@param flags widget flags.
-		 */
-		MessageWindow(QWidget* parent = 0, Qt::WFlags flags = 0);
+private:
+    static QString QtMsgToQString(QtMsgType type, const char *msg);
+
+protected:
+    /**
+         * Handle custom events. MessageWindow hadles custom events listed in
+         * EventType enum.
+         */
+    virtual void customEvent(QEvent* event);
+
+public:
+    enum EventType {MessageEventType = QEvent::User};    ///< Custom event types.
+
+    /**
+         * Default constructor.
+         *     @param parent parent widget.
+         *     @param flags widget flags.
+         */
+    MessageWindow(QWidget* parent = 0, Qt::WindowFlags flags = 0);
+
+    /**
+         * Append message wrapper. Since ISO forbids casting member functions
+         * to C functions, wrapper is needed to use this class as QtMsgHandler.
+         * This method is thread-safe but not reentrant.
+         *     @param type message type.
+         *     @param msg message string.
+         */
+    static void AppendMsgWrapper(QtMsgType type, const char *msg);
+#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
+    static void AppendMsgWrapper(QtMsgType type, const QMessageLogContext &context, const QString &msg);
+#endif
+    /**
+         * Post message event to the main event loop. This function encapsulates
+         * message into MessageEvent object and passes it to the main event loop.
+         *     @param type message type.
+         *     @param msg message string.
+         */
+    void postMsgEvent(QtMsgType type, const char *msg);
 
-		/**
-		 * Append message wrapper. Since ISO forbids casting member functions
-		 * to C functions, wrapper is needed to use this class as QtMsgHandler.
-		 * This method is thread-safe but not reentrant.
-		 * 	@param type message type.
-		 * 	@param msg message string.
-		 */
-		static void AppendMsgWrapper(QtMsgType type, const char *msg);
-		
-		/**
-		 * Post message event to the main event loop. This function encapsulates
-		 * message into MessageEvent object and passes it to the main event loop.
-		 * 	@param type message type.
-		 * 	@param msg message string.
-		 */
-		void postMsgEvent(QtMsgType type, const char *msg);
-	
 };
 
 
  */
 class MessageEvent: public QEvent
 {
-    public:
-        QString msg;	///< Message string.
+public:
+    QString msg;    ///< Message string.
 
-        /**
+    /**
          * Contructor.
-         * 	@param msg message to post.
+         *     @param msg message to post.
          */
-        MessageEvent(QString & msg);
+    MessageEvent(QString &msg);
 };
 
 #endif /*MESSAGEWINDOW_H_*/

src/3rdparty/qextserialport/examples/qespta/QespTest.cpp

 #include <QSpinBox>
 
 
-QespTest::QespTest(QWidget* parent) 
-	: QWidget(parent)
+QespTest::QespTest(QWidget *parent)
+    : QWidget(parent)
 
 {
-	//modify the port settings on your own
-    #ifdef Q_OS_UNIX
-		port = new QextSerialPort(QLatin1String("/dev/ttyS0"), QextSerialPort::Polling);
-	#else
-		port = new QextSerialPort(QLatin1String("COM1"), QextSerialPort::Polling);
-    #endif /*Q_OS_UNIX*/
-	port->setBaudRate(BAUD19200);
-	port->setFlowControl(FLOW_OFF);
-	port->setParity(PAR_NONE);
-	port->setDataBits(DATA_8);
-	port->setStopBits(STOP_2);
-	//set timeouts to 500 ms
-	port->setTimeout(500);
-	
-	message = new QLineEdit(this);
-
-	// transmit receive
-	QPushButton *transmitButton = new QPushButton(tr("Transmit"));
-	connect(transmitButton, SIGNAL(clicked()), SLOT(transmitMsg()));
-	QPushButton *receiveButton = new QPushButton(tr("Receive"));
-	connect(receiveButton, SIGNAL(clicked()), SLOT(receiveMsg()));
-	QHBoxLayout* trLayout = new QHBoxLayout;
-	trLayout->addWidget(transmitButton);
-	trLayout->addWidget(receiveButton);
-	  
-	//CR LF
-	QPushButton *CRButton = new QPushButton(tr("CR"));
-	connect(CRButton, SIGNAL(clicked()), SLOT(appendCR()));
-	QPushButton *LFButton = new QPushButton(tr("LF"));
-	connect(LFButton, SIGNAL(clicked()), SLOT(appendLF()));
-	QHBoxLayout *crlfLayout = new QHBoxLayout;
-	crlfLayout->addWidget(CRButton);
-	crlfLayout->addWidget(LFButton);
-	
-	//open close
-	QPushButton *openButton = new QPushButton(tr("Open"));
-	connect(openButton, SIGNAL(clicked()), SLOT(openPort()));
-	QPushButton *closeButton = new QPushButton(tr("Close"));
-	connect(closeButton, SIGNAL(clicked()), SLOT(closePort()));
-	QHBoxLayout *ocLayout = new QHBoxLayout;
-	ocLayout->addWidget(openButton);
-	ocLayout->addWidget(closeButton);
-	
-	received_msg = new QTextEdit();
-	  
-	QVBoxLayout *myVBox = new QVBoxLayout;
-	myVBox->addWidget(message);
-	myVBox->addLayout(crlfLayout);
-	myVBox->addLayout(trLayout);
-	myVBox->addLayout(ocLayout);
-	myVBox->addWidget(received_msg);
-	setLayout(myVBox);
-	
-	qDebug("isOpen : %d", port->isOpen());
+    //modify the port settings on your own
+#ifdef Q_OS_UNIX
+    port = new QextSerialPort(QLatin1String("/dev/ttyS0"), QextSerialPort::Polling);
+#else
+    port = new QextSerialPort(QLatin1String("COM1"), QextSerialPort::Polling);
+#endif /*Q_OS_UNIX*/
+    port->setBaudRate(BAUD19200);
+    port->setFlowControl(FLOW_OFF);
+    port->setParity(PAR_NONE);
+    port->setDataBits(DATA_8);
+    port->setStopBits(STOP_2);
+    //set timeouts to 500 ms
+    port->setTimeout(500);
+
+    message = new QLineEdit(this);
+
+    // transmit receive
+    QPushButton *transmitButton = new QPushButton(tr("Transmit"));
+    connect(transmitButton, SIGNAL(clicked()), SLOT(transmitMsg()));
+    QPushButton *receiveButton = new QPushButton(tr("Receive"));
+    connect(receiveButton, SIGNAL(clicked()), SLOT(receiveMsg()));
+    QHBoxLayout *trLayout = new QHBoxLayout;
+    trLayout->addWidget(transmitButton);
+    trLayout->addWidget(receiveButton);
+
+    //CR LF
+    QPushButton *CRButton = new QPushButton(tr("CR"));
+    connect(CRButton, SIGNAL(clicked()), SLOT(appendCR()));
+    QPushButton *LFButton = new QPushButton(tr("LF"));
+    connect(LFButton, SIGNAL(clicked()), SLOT(appendLF()));
+    QHBoxLayout *crlfLayout = new QHBoxLayout;
+    crlfLayout->addWidget(CRButton);
+    crlfLayout->addWidget(LFButton);
+
+    //open close
+    QPushButton *openButton = new QPushButton(tr("Open"));
+    connect(openButton, SIGNAL(clicked()), SLOT(openPort()));
+    QPushButton *closeButton = new QPushButton(tr("Close"));
+    connect(closeButton, SIGNAL(clicked()), SLOT(closePort()));
+    QHBoxLayout *ocLayout = new QHBoxLayout;
+    ocLayout->addWidget(openButton);
+    ocLayout->addWidget(closeButton);
+
+    received_msg = new QTextEdit();
+
+    QVBoxLayout *myVBox = new QVBoxLayout;
+    myVBox->addWidget(message);
+    myVBox->addLayout(crlfLayout);
+    myVBox->addLayout(trLayout);
+    myVBox->addLayout(ocLayout);
+    myVBox->addWidget(received_msg);
+    setLayout(myVBox);
+
+    qDebug("isOpen : %d", port->isOpen());
 }
 
 QespTest::~QespTest()
 
 void QespTest::transmitMsg()
 {
-  int i = port->write((message->text()).toAscii(),
-                       (message->text()).length());
-  qDebug("trasmitted : %d", i);
+    int i = port->write(message->text().toLatin1());
+    qDebug("trasmitted : %d", i);
 }
 
 void QespTest::receiveMsg()
 {
-	char buff[1024];
-  	int numBytes;
-  
-	numBytes = port->bytesAvailable();
-    if(numBytes > 1024) 
-    	numBytes = 1024;
+    char buff[1024];
+    int numBytes;
+
+    numBytes = port->bytesAvailable();
+    if(numBytes > 1024)
+        numBytes = 1024;
 
     int i = port->read(buff, numBytes);
     if (i != -1)
-		buff[i] = '\0';
-	else
-		buff[0] = '\0';
-	QString msg = QLatin1String(buff);
-	
-   	received_msg->append(msg);
-   	received_msg->ensureCursorVisible();
-	qDebug("bytes available: %d", numBytes);
-	qDebug("received: %d", i);
+        buff[i] = '\0';
+    else
+        buff[0] = '\0';
+    QString msg = QLatin1String(buff);
+
+    received_msg->append(msg);
+    received_msg->ensureCursorVisible();
+    qDebug("bytes available: %d", numBytes);
+    qDebug("received: %d", i);
 }
 
 
 void QespTest::appendCR()
 {
-	message->insert(QLatin1String("\x0D"));
+    message->insert(QLatin1String("\x0D"));
 }
 
 void QespTest::appendLF()
 {
-	message->insert(QLatin1String("\x0A"));
+    message->insert(QLatin1String("\x0A"));
 }
 
 void QespTest::closePort()
 {
-	port->close();
-	qDebug("is open: %d", port->isOpen());
+    port->close();
+    qDebug("is open: %d", port->isOpen());
 }
 
 void QespTest::openPort()
 {
-	port->open(QIODevice::ReadWrite | QIODevice::Unbuffered);
-	qDebug("is open: %d", port->isOpen());
+    port->open(QIODevice::ReadWrite | QIODevice::Unbuffered);
+    qDebug("is open: %d", port->isOpen());
 }
 

src/3rdparty/qextserialport/examples/qespta/QespTest.h

 
 class QespTest :  public QWidget
 {
-  Q_OBJECT
+    Q_OBJECT
 public:
-  QespTest(QWidget *parent=0);
+    QespTest(QWidget *parent=0);
 
-  virtual ~QespTest();
+    virtual ~QespTest();
 
 private:
-  QLineEdit *message;
-  QSpinBox* delaySpinBox;
-  QTextEdit *received_msg;
-  QextSerialPort *port;
+    QLineEdit *message;
+    QSpinBox *delaySpinBox;
+    QTextEdit *received_msg;
+    QextSerialPort *port;
 
 private slots:
-  void transmitMsg();
-  void receiveMsg();
-  void appendCR();
-  void appendLF();
-  void closePort();
-  void openPort();
+    void transmitMsg();
+    void receiveMsg();
+    void appendCR();
+    void appendLF();
+    void closePort();
+    void openPort();
 };
 
 #endif

src/3rdparty/qextserialport/examples/qespta/main.cpp

 
 int main(int argc, char *argv[])
 {
-	QApplication app(argc, argv);
+    QApplication app(argc, argv);
     //! [0]
+#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
     //redirect debug messages to the MessageWindow dialog
-	qInstallMsgHandler(MessageWindow::AppendMsgWrapper);
+    qInstallMsgHandler(MessageWindow::AppendMsgWrapper);
+#else
+    qInstallMessageHandler(MessageWindow::AppendMsgWrapper);
+#endif
     //! [0]
 
     MainWindow mainWindow;
-	mainWindow.show();
+    mainWindow.show();
 
     return app.exec();
 }

src/3rdparty/qextserialport/examples/qespta/qespta.pro

 QT += core gui
 contains(QT_VERSION, ^5\\..*\\..*): QT += widgets
 HEADERS += MainWindow.h \
-		MessageWindow.h \
+        MessageWindow.h \
         QespTest.h
 
 SOURCES += main.cpp \
-		MainWindow.cpp \
-		MessageWindow.cpp \
-		QespTest.cpp
+           MainWindow.cpp \
+           MessageWindow.cpp \
+           QespTest.cpp
 
 include(../../src/qextserialport.pri)

src/3rdparty/qextserialport/examples/uartassistant/dialog.cpp

 #include "qextserialport.h"
+#include "qextserialenumerator.h"
 #include "dialog.h"
 #include "ui_dialog.h"
 #include <QtCore>
     ui->setupUi(this);
 
     //! [0]
-#ifdef Q_OS_WIN
-    ui->portBox->addItems(QStringList()<<"COM1"<<"COM2"<<"COM3"<<"COM4");
-#else
-    ui->portBox->addItems(QStringList()<<"/dev/ttyS0"<<"/dev/ttyS1"<<"/dev/ttyUSB0"<<"/dev/ttyUSB1");
-#endif
+    foreach (QextPortInfo info, QextSerialEnumerator::getPorts())
+        ui->portBox->addItem(info.portName);
     //make sure user can input their own port name!
     ui->portBox->setEditable(true);
 
     PortSettings settings = {BAUD9600, DATA_8, PAR_NONE, STOP_1, FLOW_OFF, 10};
     port = new QextSerialPort(ui->portBox->currentText(), settings, QextSerialPort::Polling);
     //! [1]
+
+    enumerator = new QextSerialEnumerator(this);
+    enumerator->setUpNotifications();
+
     connect(ui->baudRateBox, SIGNAL(currentIndexChanged(int)), SLOT(onBaudRateChanged(int)));
     connect(ui->parityBox, SIGNAL(currentIndexChanged(int)), SLOT(onParityChanged(int)));
     connect(ui->dataBitsBox, SIGNAL(currentIndexChanged(int)), SLOT(onDataBitsChanged(int)));
     connect(timer, SIGNAL(timeout()), SLOT(onReadyRead()));
     connect(port, SIGNAL(readyRead()), SLOT(onReadyRead()));
 
+    connect(enumerator, SIGNAL(deviceDiscovered(QextPortInfo)), SLOT(onPortAddedOrRemoved()));
+    connect(enumerator, SIGNAL(deviceRemoved(QextPortInfo)), SLOT(onPortAddedOrRemoved()));
+
     setWindowTitle(tr("QextSerialPort Demo"));
 }
 
         ui->recvEdit->insertPlainText(QString::fromLatin1(port->readAll()));
     }
 }
+
+void Dialog::onPortAddedOrRemoved()
+{
+    QString current = ui->portBox->currentText();
+
+    ui->portBox->blockSignals(true);
+    ui->portBox->clear();
+    foreach (QextPortInfo info, QextSerialEnumerator::getPorts())
+        ui->portBox->addItem(info.portName);
+
+    ui->portBox->setCurrentIndex(ui->portBox->findText(current));
+
+    ui->portBox->blockSignals(false);
+}
+
 //! [4]

src/3rdparty/qextserialport/examples/uartassistant/dialog.h

 }
 class QTimer;
 class QextSerialPort;
+class QextSerialEnumerator;
 
 class Dialog : public QDialog
 {
     void onSendButtonClicked();
     void onReadyRead();
 
+    void onPortAddedOrRemoved();
+
 private:
     Ui::Dialog *ui;
     QTimer *timer;
     QextSerialPort *port;
+    QextSerialEnumerator *enumerator;
 };
 
 #endif // DIALOG_H

src/3rdparty/qextserialport/examples/uartassistant/hled.cpp

     turnOn(!off);
 }
 
-void HLed::paintEvent(QPaintEvent* /* event*/)
+void HLed::paintEvent(QPaintEvent * /*event*/)
 {
     int width = ledWidth();
 

src/3rdparty/qextserialport/examples/uartassistant/hled.h

     void turnOff(bool off=true);
 
 protected:
-    void paintEvent(QPaintEvent*);
+    void paintEvent(QPaintEvent *);
     int ledWidth() const;
 
 private:

src/3rdparty/qextserialport/extserialport.prf.in

+defineReplace(qextLibraryName) {
+   unset(LIBRARY_NAME)
+   LIBRARY_NAME = \$\$1
+   greaterThan(QT_MAJOR_VERSION, 4):LIBRARY_NAME ~= s,^Qt,Qt\$\$QT_MAJOR_VERSION,
+   CONFIG(debug, debug|release) {
+      !debug_and_release|build_pass {
+          mac:LIBRARY_NAME = \$\${LIBRARY_NAME}_debug
+          else:win32:LIBRARY_NAME = \$\${LIBRARY_NAME}d
+      }
+   }
+   return(\$\$LIBRARY_NAME)
+}
+
+!!IF qesp_mac_framework
+LIBS += -framework $$QESP_LIB_BASENAME
+INCLUDEPATH += $$[QT_INSTALL_LIBS]/$${QESP_LIB_BASENAME}.framework/Headers
+!!ELSE
+LIBS += -l\$\$qextLibraryName($$QESP_LIB_BASENAME)
+INCLUDEPATH += $$[QT_INSTALL_HEADERS]/QtExtSerialPort
+!!ENDIF
+
+!!IF !qesp_static
+DEFINES += QEXTSERIALPORT_USING_SHARED
+!!ENDIF

src/3rdparty/qextserialport/qextserialport.pro

-TEMPLATE=subdirs
-CONFIG += ordered
-include(common.pri)
-qextserialport-library:SUBDIRS=buildlib
-SUBDIRS+=examples
+############################### *User Config* ###############################
 
+# Uncomment following line if you want to build a static library
+# CONFIG += qesp_static
+
+# Uncomment following line if you want to build framework for mac
+# macx:CONFIG += qesp_mac_framework
+
+# Uncomment following line if you want to enable udev for linux
+# linux*:CONFIG += qesp_linux_udev
+
+# Note: you can create a ".qmake.cache" file, then copy these lines to it.
+# If so, you can avoid to change this project file.
+############################### *User Config* ###############################
+
+defineReplace(qextLibraryName) {
+   unset(LIBRARY_NAME)
+   LIBRARY_NAME = $$1
+   macx:qesp_mac_framework {
+      QMAKE_FRAMEWORK_BUNDLE_NAME = $$LIBRARY_NAME
+      export(QMAKE_FRAMEWORK_BUNDLE_NAME)
+   } else {
+       greaterThan(QT_MAJOR_VERSION, 4):LIBRARY_NAME ~= s,^Qt,Qt$$QT_MAJOR_VERSION,
+   }
+   CONFIG(debug, debug|release) {
+      !debug_and_release|build_pass {
+          mac:LIBRARY_NAME = $${LIBRARY_NAME}_debug
+          else:win32:LIBRARY_NAME = $${LIBRARY_NAME}d
+      }
+   }
+   return($$LIBRARY_NAME)
+}
+
+TEMPLATE=lib
+include(src/qextserialport.pri)
+
+#create_prl is needed, otherwise, MinGW can't found libqextserialport1.a
+CONFIG += create_prl
+
+#mac framework is designed for shared library
+macx:qesp_mac_framework:qesp_static: CONFIG -= qesp_static
+!macx:qesp_mac_framework:CONFIG -= qesp_mac_framework
+
+qesp_static {
+    CONFIG += static
+} else {
+    CONFIG += shared
+    macx:!qesp_mac_framework:CONFIG += absolute_library_soname
+    DEFINES += QEXTSERIALPORT_BUILD_SHARED
+}
+
+#Creare lib bundle for mac
+macx:qesp_mac_framework {
+    CONFIG += lib_bundle
+    FRAMEWORK_HEADERS.files = $$PUBLIC_HEADERS
+    FRAMEWORK_HEADERS.path = Headers
+    QMAKE_BUNDLE_DATA += FRAMEWORK_HEADERS
+}
+
+win32|mac:!wince*:!win32-msvc:!macx-xcode:CONFIG += debug_and_release build_all
+
+#For non-windows system, only depends on QtCore module
+unix:QT = core
+else:QT = core gui
+
+#generate proper library name
+greaterThan(QT_MAJOR_VERSION, 4) {
+    QESP_LIB_BASENAME = QtExtSerialPort
+} else {
+    QESP_LIB_BASENAME = qextserialport
+}
+TARGET = $$qextLibraryName($$QESP_LIB_BASENAME)
+VERSION = 1.2.0
+
+# generate feature file by qmake based on this *.in file.
+QMAKE_SUBSTITUTES += extserialport.prf.in
+OTHER_FILES += extserialport.prf.in
+
+# for make docs
 include(doc/doc.pri)
+
+# for make install
+win32:!qesp_static {
+    dlltarget.path = $$[QT_INSTALL_BINS]
+    INSTALLS += dlltarget
+}
+!macx|!qesp_mac_framework {
+    headers.files = $$PUBLIC_HEADERS
+    headers.path = $$[QT_INSTALL_HEADERS]/QtExtSerialPort
+    INSTALLS += headers
+}
+target.path = $$[QT_INSTALL_LIBS]
+
+features.files = extserialport.prf
+features.path = $$[QMAKE_MKSPECS]/features
+INSTALLS += target features

src/3rdparty/qextserialport/src/extserialport/qextserialport_win.cpp

-/****************************************************************************
-** Copyright (c) 2000-2003 Wayne Roth
-** Copyright (c) 2004-2007 Stefan Sander
-** Copyright (c) 2007 Michal Policht
-** Copyright (c) 2008 Brandon Fosdick
-** Copyright (c) 2009-2010 Liam Staskawicz
-** Copyright (c) 2011 Debao Zhang
-** All right reserved.
-** Web: http://code.google.com/p/qextserialport/
-**
-** Permission is hereby granted, free of charge, to any person obtaining
-** a copy of this software and associated documentation files (the
-** "Software"), to deal in the Software without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Software, and to
-** permit persons to whom the Software is furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be
-** included in all copies or substantial portions of the Software.
-**
-** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**
-****************************************************************************/
-
-#include "qextserialport.h"
-#include "qextserialport_p.h"
-#include <QtCore/QThread>
-#include <QtCore/QReadWriteLock>
-#include <QtCore/QMutexLocker>
-#include <QtCore/QDebug>
-#include <QtCore/QRegExp>
-#include <QtCore/QMetaType>
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
-#  include <QtCore/QWinEventNotifier>
-#  define WinEventNotifier QWinEventNotifier
-#elif !defined(QESP_NO_QT4_PRIVATE)
-#  include <QtCore/private/qwineventnotifier_p.h>
-#  define WinEventNotifier QWinEventNotifier
-#else
-#  include "qextwineventnotifier_p.h"
-#  define WinEventNotifier QextWinEventNotifier
-#endif
-void QextSerialPortPrivate::platformSpecificInit()
-{
-    Win_Handle=INVALID_HANDLE_VALUE;
-    ZeroMemory(&overlap, sizeof(OVERLAPPED));
-    overlap.hEvent = CreateEvent(NULL, true, false, NULL);
-    winEventNotifier = 0;
-    bytesToWriteLock = new QReadWriteLock;
-    _bytesToWrite = 0;
-}
-
-void QextSerialPortPrivate::platformSpecificDestruct() {
-    CloseHandle(overlap.hEvent);
-    delete bytesToWriteLock;
-}
-
-
-/*!
-    \internal
-    COM ports greater than 9 need \\.\ prepended
-
-    This is only need when open the port.
-*/
-static QString fullPortNameWin(const QString & name)
-{
-    QRegExp rx(QLatin1String("^COM(\\d+)"));
-    QString fullName(name);
-    if(fullName.contains(rx))
-        fullName.prepend(QLatin1String("\\\\.\\"));
-    return fullName;
-}
-
-bool QextSerialPortPrivate::open_sys(QIODevice::OpenMode mode)
-{
-    Q_Q(QextSerialPort);
-    DWORD confSize = sizeof(COMMCONFIG);
-    Win_CommConfig.dwSize = confSize;
-    DWORD dwFlagsAndAttributes = 0;
-    if (_queryMode == QextSerialPort::EventDriven)
-        dwFlagsAndAttributes += FILE_FLAG_OVERLAPPED;
-
-    /*open the port*/
-    Win_Handle=CreateFileW((wchar_t*)fullPortNameWin(port).utf16(), GENERIC_READ|GENERIC_WRITE,
-                           0, NULL, OPEN_EXISTING, dwFlagsAndAttributes, NULL);
-    if (Win_Handle!=INVALID_HANDLE_VALUE) {
-        q->setOpenMode(mode);
-        /*configure port settings*/
-        GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
-        GetCommState(Win_Handle, &(Win_CommConfig.dcb));
-
-        /*set up parameters*/
-        Win_CommConfig.dcb.fBinary=TRUE;
-        Win_CommConfig.dcb.fInX=FALSE;
-        Win_CommConfig.dcb.fOutX=FALSE;
-        Win_CommConfig.dcb.fAbortOnError=FALSE;
-        Win_CommConfig.dcb.fNull=FALSE;
-        /* Dtr default to true. See Issue 122*/
-        Win_CommConfig.dcb.fDtrControl=TRUE;
-        /*flush all settings*/
-        settingsDirtyFlags = DFE_ALL;
-        updatePortSettings();
-
-        //init event driven approach
-        if (_queryMode == QextSerialPort::EventDriven) {
-            if (!SetCommMask( Win_Handle, EV_TXEMPTY | EV_RXCHAR | EV_DSR)) {
-                QESP_WARNING()<<"failed to set Comm Mask. Error code:"<<GetLastError();
-                return false;
-            }
-            winEventNotifier = new WinEventNotifier(overlap.hEvent, q);
-            qRegisterMetaType<HANDLE>("HANDLE");
-            q->connect(winEventNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_onWinEvent(HANDLE)), Qt::DirectConnection);
-            WaitCommEvent(Win_Handle, &eventMask, &overlap);
-        }
-        return true;
-    }
-    return false;
-}
-
-bool QextSerialPortPrivate::close_sys()
-{
-    flush_sys();
-    CancelIo(Win_Handle);
-    if (CloseHandle(Win_Handle))
-        Win_Handle = INVALID_HANDLE_VALUE;
-    if (winEventNotifier){
-        winEventNotifier->setEnabled(false);
-        winEventNotifier->deleteLater();
-        winEventNotifier = 0;
-    }
-    _bytesToWrite = 0;
-
-    foreach(OVERLAPPED* o, pendingWrites) {
-        CloseHandle(o->hEvent);
-        delete o;
-    }
-    pendingWrites.clear();
-    return true;
-}
-
-bool QextSerialPortPrivate::flush_sys()
-{
-    FlushFileBuffers(Win_Handle);
-    return true;
-}
-
-qint64 QextSerialPortPrivate::bytesAvailable_sys() const
-{
-    DWORD Errors;
-    COMSTAT Status;
-    if (ClearCommError(Win_Handle, &Errors, &Status)) {
-        return Status.cbInQue;
-    }
-    return (qint64)-1;
-}
-
-/*
-    Translates a system-specific error code to a QextSerialPort error code.  Used internally.
-*/
-void QextSerialPortPrivate::translateError(ulong error)
-{
-    if (error&CE_BREAK) {
-        lastErr=E_BREAK_CONDITION;
-    }
-    else if (error&CE_FRAME) {
-        lastErr=E_FRAMING_ERROR;
-    }
-    else if (error&CE_IOE) {
-        lastErr=E_IO_ERROR;
-    }
-    else if (error&CE_MODE) {
-        lastErr=E_INVALID_FD;
-    }
-    else if (error&CE_OVERRUN) {
-        lastErr=E_BUFFER_OVERRUN;
-    }
-    else if (error&CE_RXPARITY) {
-        lastErr=E_RECEIVE_PARITY_ERROR;
-    }
-    else if (error&CE_RXOVER) {
-        lastErr=E_RECEIVE_OVERFLOW;
-    }
-    else if (error&CE_TXFULL) {
-        lastErr=E_TRANSMIT_OVERFLOW;
-    }
-}
-
-/*
-    Reads a block of data from the serial port.  This function will read at most maxlen bytes from
-    the serial port and place them in the buffer pointed to by data.  Return value is the number of
-    bytes actually read, or -1 on error.
-    
-    \warning before calling this function ensure that serial port associated with this class
-    is currently open (use isOpen() function to check if port is open).
-*/
-qint64 QextSerialPortPrivate::readData_sys(char *data, qint64 maxSize)
-{
-    DWORD bytesRead = 0;
-    bool failed = false;
-    if (_queryMode == QextSerialPort::EventDriven) {
-        OVERLAPPED overlapRead;
-        ZeroMemory(&overlapRead, sizeof(OVERLAPPED));
-        if (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesRead, & overlapRead)) {
-            if (GetLastError() == ERROR_IO_PENDING)
-                GetOverlappedResult(Win_Handle, & overlapRead, & bytesRead, true);
-            else
-                failed = true;
-        }
-    } else if (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesRead, NULL)) {
-        failed = true;
-    }
-    if (!failed)
-        return (qint64)bytesRead;
-
-    lastErr = E_READ_FAILED;
-    return -1;
-}
-
-/*
-    Writes a block of data to the serial port.  This function will write len bytes
-    from the buffer pointed to by data to the serial port.  Return value is the number
-    of bytes actually written, or -1 on error.
-    
-    \warning before calling this function ensure that serial port associated with this class
-    is currently open (use isOpen() function to check if port is open).
-*/
-qint64 QextSerialPortPrivate::writeData_sys(const char *data, qint64 maxSize)
-{
-    DWORD bytesWritten = 0;
-    bool failed = false;
-    if (_queryMode == QextSerialPort::EventDriven) {
-        OVERLAPPED* newOverlapWrite = new OVERLAPPED;
-        ZeroMemory(newOverlapWrite, sizeof(OVERLAPPED));
-        newOverlapWrite->hEvent = CreateEvent(NULL, true, false, NULL);
-        if (WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesWritten, newOverlapWrite)) {
-            CloseHandle(newOverlapWrite->hEvent);
-            delete newOverlapWrite;
-        }
-        else if (GetLastError() == ERROR_IO_PENDING) {
-            // writing asynchronously...not an error
-            QWriteLocker writelocker(bytesToWriteLock);
-            _bytesToWrite += maxSize;
-            pendingWrites.append(newOverlapWrite);
-        }
-        else {
-            QESP_WARNING()<<"QextSerialPort write error:"<<GetLastError();
-            failed = true;
-            if(!CancelIo(newOverlapWrite->hEvent))
-                QESP_WARNING("QextSerialPort: couldn't cancel IO");
-            if(!CloseHandle(newOverlapWrite->hEvent))
-                QESP_WARNING("QextSerialPort: couldn't close OVERLAPPED handle");
-            delete newOverlapWrite;
-        }
-    } else if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesWritten, NULL)) {
-        failed = true;
-    }
-
-    if (!failed)
-        return (qint64)bytesWritten;
-
-    lastErr = E_WRITE_FAILED;
-    return -1;
-}
-
-void QextSerialPortPrivate::setDtr_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETDTR : CLRDTR);
-}
-
-void QextSerialPortPrivate::setRts_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETRTS : CLRRTS);
-}
-
-ulong QextSerialPortPrivate::lineStatus_sys(void) {
-    unsigned long Status=0, Temp=0;
-    GetCommModemStatus(Win_Handle, &Temp);
-    if (Temp & MS_CTS_ON) Status|=LS_CTS;
-    if (Temp & MS_DSR_ON) Status|=LS_DSR;
-    if (Temp & MS_RING_ON) Status|=LS_RI;
-    if (Temp & MS_RLSD_ON) Status|=LS_DCD;
-    return Status;
-}
-
-/*
-  Triggered when there's activity on our HANDLE.
-*/
-void QextSerialPortPrivate::_q_onWinEvent(HANDLE h)
-{
-    Q_Q(QextSerialPort);
-    if(h == overlap.hEvent) {
-        if (eventMask & EV_RXCHAR) {
-            if (q->sender() != q && bytesAvailable_sys() > 0)
-                _q_canRead();
-        }
-        if (eventMask & EV_TXEMPTY) {
-            /*
-              A write completed.  Run through the list of OVERLAPPED writes, and if
-              they completed successfully, take them off the list and delete them.
-              Otherwise, leave them on there so they can finish.
-            */
-            qint64 totalBytesWritten = 0;
-            QList<OVERLAPPED*> overlapsToDelete;
-            foreach(OVERLAPPED* o, pendingWrites) {
-                DWORD numBytes = 0;
-                if (GetOverlappedResult(Win_Handle, o, & numBytes, false)) {
-                    overlapsToDelete.append(o);
-                    totalBytesWritten += numBytes;
-                } else if( GetLastError() != ERROR_IO_INCOMPLETE ) {
-                    overlapsToDelete.append(o);
-                    QESP_WARNING()<<"CommEvent overlapped write error:" << GetLastError();
-                }
-            }
-
-            if (q->sender() != q && totalBytesWritten > 0) {
-                QWriteLocker writelocker(bytesToWriteLock);
-                Q_EMIT q->bytesWritten(totalBytesWritten);
-                _bytesToWrite = 0;
-            }
-
-            foreach(OVERLAPPED* o, overlapsToDelete) {
-                OVERLAPPED *toDelete = pendingWrites.takeAt(pendingWrites.indexOf(o));
-                CloseHandle(toDelete->hEvent);
-                delete toDelete;
-            }
-        }
-        if (eventMask & EV_DSR) {
-            if (lineStatus_sys() & LS_DSR)
-                Q_EMIT q->dsrChanged(true);
-            else
-                Q_EMIT q->dsrChanged(false);
-        }
-    }
-    WaitCommEvent(Win_Handle, &eventMask, &overlap);
-}
-
-void QextSerialPortPrivate::updatePortSettings()
-{
-    if (!q_ptr->isOpen() || !settingsDirtyFlags)
-        return;
-
-    //fill struct : COMMCONFIG
-    if (settingsDirtyFlags & DFE_BaudRate) {
-        Win_CommConfig.dcb.BaudRate = Settings.BaudRate;
-    }
-    if (settingsDirtyFlags & DFE_Parity) {
-        Win_CommConfig.dcb.Parity = (BYTE)Settings.Parity;
-        Win_CommConfig.dcb.fParity = (Settings.Parity == PAR_NONE) ? FALSE : TRUE;
-    }
-    if (settingsDirtyFlags & DFE_DataBits) {
-        Win_CommConfig.dcb.ByteSize = (BYTE)Settings.DataBits;
-    }
-    if (settingsDirtyFlags & DFE_StopBits) {
-        switch (Settings.StopBits) {
-        case STOP_1:
-            Win_CommConfig.dcb.StopBits = ONESTOPBIT;
-            break;
-        case STOP_1_5:
-            Win_CommConfig.dcb.StopBits = ONE5STOPBITS;
-            break;
-        case STOP_2:
-            Win_CommConfig.dcb.StopBits = TWOSTOPBITS;
-            break;
-        }
-    }
-    if (settingsDirtyFlags & DFE_Flow) {
-        switch(Settings.FlowControl) {
-        /*no flow control*/
-        case FLOW_OFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
-            break;
-        /*software (XON/XOFF) flow control*/
-        case FLOW_XONXOFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=TRUE;
-            Win_CommConfig.dcb.fOutX=TRUE;
-            break;
-        /*hardware flow control*/
-        case FLOW_HARDWARE:
-            Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
-            break;
-        }
-    }
-
-    //fill struct : COMMTIMEOUTS
-    if (settingsDirtyFlags & DFE_TimeOut) {
-        if (_queryMode != QextSerialPort::EventDriven) {
-            int millisec = Settings.Timeout_Millisec;
-            if (millisec == -1) {
-                Win_CommTimeouts.ReadIntervalTimeout = MAXDWORD;
-                Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
-            } else {
-                Win_CommTimeouts.ReadIntervalTimeout = millisec;
-                Win_CommTimeouts.ReadTotalTimeoutConstant = millisec;
-            }
-            Win_CommTimeouts.ReadTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.WriteTotalTimeoutMultiplier = millisec;
-            Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
-        }
-        else {
-            Win_CommTimeouts.ReadIntervalTimeout = MAXDWORD;
-            Win_CommTimeouts.ReadTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
-            Win_CommTimeouts.WriteTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
-        }
-    }
-
-
-    if (settingsDirtyFlags & DFE_Settings_Mask)
-        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
-    if ((settingsDirtyFlags & DFE_TimeOut))
-        SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
-    settingsDirtyFlags = 0;
-}

src/3rdparty/qextserialport/src/extserialport/qextserialport_win.cpp.orig

-/****************************************************************************
-** Copyright (c) 2000-2003 Wayne Roth
-** Copyright (c) 2004-2007 Stefan Sander
-** Copyright (c) 2007 Michal Policht
-** Copyright (c) 2008 Brandon Fosdick
-** Copyright (c) 2009-2010 Liam Staskawicz
-** Copyright (c) 2011 Debao Zhang
-** All right reserved.
-** Web: http://code.google.com/p/qextserialport/
-**
-** Permission is hereby granted, free of charge, to any person obtaining
-** a copy of this software and associated documentation files (the
-** "Software"), to deal in the Software without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Software, and to
-** permit persons to whom the Software is furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be
-** included in all copies or substantial portions of the Software.
-**
-** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**
-****************************************************************************/
-
-#include "qextserialport.h"
-#include "qextserialport_p.h"
-#include <QtCore/QThread>
-#include <QtCore/QReadWriteLock>
-#include <QtCore/QMutexLocker>
-#include <QtCore/QDebug>
-#include <QtCore/QRegExp>
-#include <QtCore/QMetaType>
-#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-#  include <QtCore/private/qwineventnotifier_p.h>
-#else
-#  include <QtCore/QWinEventNotifier>
-#endif
-
-void QextSerialPortPrivate::platformSpecificInit()
-{
-    Win_Handle=INVALID_HANDLE_VALUE;
-    ZeroMemory(&overlap, sizeof(OVERLAPPED));
-    overlap.hEvent = CreateEvent(NULL, true, false, NULL);
-    winEventNotifier = 0;
-    bytesToWriteLock = new QReadWriteLock;
-    _bytesToWrite = 0;
-}
-
-void QextSerialPortPrivate::platformSpecificDestruct() {
-    CloseHandle(overlap.hEvent);
-    delete bytesToWriteLock;
-}
-
-
-/*!
-    \internal
-    COM ports greater than 9 need \\.\ prepended
-
-    This is only need when open the port.
-*/
-static QString fullPortNameWin(const QString & name)
-{
-    QRegExp rx(QLatin1String("^COM(\\d+)"));
-    QString fullName(name);
-    if(fullName.contains(rx))
-        fullName.prepend(QLatin1String("\\\\.\\"));
-    return fullName;
-}
-
-bool QextSerialPortPrivate::open_sys(QIODevice::OpenMode mode)
-{
-    Q_Q(QextSerialPort);
-    DWORD confSize = sizeof(COMMCONFIG);
-    Win_CommConfig.dwSize = confSize;
-    DWORD dwFlagsAndAttributes = FILE_FLAG_OVERLAPPED;
-
-    /*open the port*/
-    Win_Handle=CreateFileW((wchar_t*)fullPortNameWin(port).utf16(), GENERIC_READ|GENERIC_WRITE,
-                           0, NULL, OPEN_EXISTING, dwFlagsAndAttributes, NULL);
-    if (Win_Handle!=INVALID_HANDLE_VALUE) {
-        q->setOpenMode(mode);
-        /*configure port settings*/
-        GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
-        GetCommState(Win_Handle, &(Win_CommConfig.dcb));
-
-        /*set up parameters*/
-        Win_CommConfig.dcb.fBinary=TRUE;
-        Win_CommConfig.dcb.fInX=FALSE;
-        Win_CommConfig.dcb.fOutX=FALSE;
-        Win_CommConfig.dcb.fAbortOnError=FALSE;
-        Win_CommConfig.dcb.fNull=FALSE;
-        /* Dtr default to true. See Issue 122*/
-        Win_CommConfig.dcb.fDtrControl=TRUE;
-        /*flush all settings*/
-        settingsDirtyFlags = DFE_ALL;
-        updatePortSettings();
-
-        //init event driven approach
-<<<<<<< local
-        if (_queryMode == QextSerialPort::EventDriven) {
-            if (!SetCommMask( Win_Handle, EV_TXEMPTY | EV_RXCHAR | EV_DSR)) {
-                QESP_WARNING()<<"failed to set Comm Mask. Error code:"<<GetLastError();
-                return false;
-            }
-            winEventNotifier = new WinEventNotifier(overlap.hEvent);
-            qRegisterMetaType<HANDLE>("HANDLE");
-            q->connect(winEventNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_onWinEvent(HANDLE)), Qt::DirectConnection);
-            WaitCommEvent(Win_Handle, &eventMask, &overlap);
-=======
-        if (!SetCommMask( Win_Handle, EV_TXEMPTY | EV_RXCHAR | EV_DSR)) {
-            QESP_WARNING()<<"failed to set Comm Mask. Error code:"<<GetLastError();
-            return false;
->>>>>>> other
-        }
-        winEventNotifier = new QWinEventNotifier(overlap.hEvent, q);
-        qRegisterMetaType<HANDLE>("HANDLE");
-        q->connect(winEventNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_onWinEvent(HANDLE)), Qt::DirectConnection);
-        WaitCommEvent(Win_Handle, &eventMask, &overlap);
-        return true;
-    }
-    return false;
-}
-
-bool QextSerialPortPrivate::close_sys()
-{
-    flush_sys();
-    CancelIo(Win_Handle);
-    if (CloseHandle(Win_Handle))
-        Win_Handle = INVALID_HANDLE_VALUE;
-    if (winEventNotifier){
-        winEventNotifier->setEnabled(false);
-        winEventNotifier->deleteLater();
-        winEventNotifier = 0;
-    }
-    _bytesToWrite = 0;
-
-    foreach(OVERLAPPED* o, pendingWrites) {
-        CloseHandle(o->hEvent);
-        delete o;
-    }
-    pendingWrites.clear();
-    return true;
-}
-
-bool QextSerialPortPrivate::flush_sys()
-{
-    FlushFileBuffers(Win_Handle);
-    return true;
-}
-
-qint64 QextSerialPortPrivate::bytesAvailable_sys() const
-{
-    DWORD Errors;
-    COMSTAT Status;
-    if (ClearCommError(Win_Handle, &Errors, &Status)) {
-        return Status.cbInQue;
-    }
-    return (qint64)-1;
-}
-
-/*
-    Translates a system-specific error code to a QextSerialPort error code.  Used internally.
-*/
-void QextSerialPortPrivate::translateError(ulong error) {
-    if (error&CE_BREAK) {
-        lastErr=QextSerialPort::E_BREAK_CONDITION;
-    }
-    else if (error&CE_FRAME) {
-        lastErr=QextSerialPort::E_FRAMING_ERROR;
-    }
-    else if (error&CE_IOE) {
-        lastErr=QextSerialPort::E_IO_ERROR;
-    }
-    else if (error&CE_MODE) {
-        lastErr=QextSerialPort::E_INVALID_FD;
-    }
-    else if (error&CE_OVERRUN) {
-        lastErr=QextSerialPort::E_BUFFER_OVERRUN;
-    }
-    else if (error&CE_RXPARITY) {
-        lastErr=QextSerialPort::E_RECEIVE_PARITY_ERROR;
-    }
-    else if (error&CE_RXOVER) {
-        lastErr=QextSerialPort::E_RECEIVE_OVERFLOW;
-    }
-    else if (error&CE_TXFULL) {
-        lastErr=QextSerialPort::E_TRANSMIT_OVERFLOW;
-    }
-}
-
-/*
-    Reads a block of data from the serial port.  This function will read at most maxlen bytes from
-    the serial port and place them in the buffer pointed to by data.  Return value is the number of
-    bytes actually read, or -1 on error.
-    
-    \warning before calling this function ensure that serial port associated with this class
-    is currently open (use isOpen() function to check if port is open).
-*/
-qint64 QextSerialPortPrivate::readData_sys(char *data, qint64 maxSize)
-{
-    DWORD bytesRead = 0;
-    bool failed = false;
-    OVERLAPPED overlapRead;
-    ZeroMemory(&overlapRead, sizeof(OVERLAPPED));
-    if (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesRead, & overlapRead)) {
-        if (GetLastError() == ERROR_IO_PENDING)
-            GetOverlappedResult(Win_Handle, & overlapRead, & bytesRead, true);
-        else
-            failed = true;
-    }
-
-    if (!failed)
-        return (qint64)bytesRead;
-
-    lastErr = QextSerialPort::E_READ_FAILED;
-    return -1;
-}
-
-/*
-    Writes a block of data to the serial port.  This function will write len bytes
-    from the buffer pointed to by data to the serial port.  Return value is the number
-    of bytes actually written, or -1 on error.
-    
-    \warning before calling this function ensure that serial port associated with this class
-    is currently open (use isOpen() function to check if port is open).
-*/
-qint64 QextSerialPortPrivate::writeData_sys(const char *data, qint64 maxSize)
-{
-    DWORD bytesWritten = 0;
-    bool failed = false;
-    OVERLAPPED* newOverlapWrite = new OVERLAPPED;
-    ZeroMemory(newOverlapWrite, sizeof(OVERLAPPED));
-    newOverlapWrite->hEvent = CreateEvent(NULL, true, false, NULL);
-    if (WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesWritten, newOverlapWrite)) {
-        CloseHandle(newOverlapWrite->hEvent);
-        delete newOverlapWrite;
-    }
-    else if (GetLastError() == ERROR_IO_PENDING) {
-        // writing asynchronously...not an error
-        QWriteLocker writelocker(bytesToWriteLock);
-        _bytesToWrite += maxSize;
-        pendingWrites.append(newOverlapWrite);
-    }
-    else {
-        QESP_WARNING()<<"QextSerialPort write error:"<<GetLastError();
-        failed = true;
-        if(!CancelIo(newOverlapWrite->hEvent))
-            QESP_WARNING("QextSerialPort: couldn't cancel IO");
-        if(!CloseHandle(newOverlapWrite->hEvent))
-            QESP_WARNING("QextSerialPort: couldn't close OVERLAPPED handle");
-        delete newOverlapWrite;
-    }
-
-    if (!failed)
-        return (qint64)bytesWritten;
-
-    lastErr = QextSerialPort::E_WRITE_FAILED;
-    return -1;
-}
-
-void QextSerialPortPrivate::setDtr_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETDTR : CLRDTR);
-}
-
-void QextSerialPortPrivate::setRts_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETRTS : CLRRTS);
-}
-
-ulong QextSerialPortPrivate::lineStatus_sys(void) {
-    unsigned long Status=0, Temp=0;
-    GetCommModemStatus(Win_Handle, &Temp);
-    if (Temp & MS_CTS_ON) Status|=QextSerialPort::LS_CTS;
-    if (Temp & MS_DSR_ON) Status|=QextSerialPort::LS_DSR;
-    if (Temp & MS_RING_ON) Status|=QextSerialPort::LS_RI;
-    if (Temp & MS_RLSD_ON) Status|=QextSerialPort::LS_DCD;
-    return Status;
-}
-
-/*
-  Triggered when there's activity on our HANDLE.
-*/
-void QextSerialPortPrivate::_q_onWinEvent(HANDLE h)
-{
-    Q_Q(QextSerialPort);
-    if(h == overlap.hEvent) {
-        if (eventMask & EV_RXCHAR) {
-            if (q->sender() != q && bytesAvailable_sys() > 0)
-                _q_canRead();
-        }
-        if (eventMask & EV_TXEMPTY) {
-            /*
-              A write completed.  Run through the list of OVERLAPPED writes, and if
-              they completed successfully, take them off the list and delete them.
-              Otherwise, leave them on there so they can finish.
-            */
-            qint64 totalBytesWritten = 0;
-            QList<OVERLAPPED*> overlapsToDelete;
-            foreach(OVERLAPPED* o, pendingWrites) {
-                DWORD numBytes = 0;
-                if (GetOverlappedResult(Win_Handle, o, & numBytes, false)) {
-                    overlapsToDelete.append(o);
-                    totalBytesWritten += numBytes;
-                } else if( GetLastError() != ERROR_IO_INCOMPLETE ) {
-                    overlapsToDelete.append(o);
-                    QESP_WARNING()<<"CommEvent overlapped write error:" << GetLastError();
-                }
-            }
-
-            if (q->sender() != q && totalBytesWritten > 0) {
-                QWriteLocker writelocker(bytesToWriteLock);
-                Q_EMIT q->bytesWritten(totalBytesWritten);
-                _bytesToWrite = 0;
-            }
-
-            foreach(OVERLAPPED* o, overlapsToDelete) {
-                OVERLAPPED *toDelete = pendingWrites.takeAt(pendingWrites.indexOf(o));
-                CloseHandle(toDelete->hEvent);
-                delete toDelete;
-            }
-        }
-        if (eventMask & EV_DSR) {
-            if (lineStatus_sys() & QextSerialPort::LS_DSR)
-                Q_EMIT q->dsrChanged(true);
-            else
-                Q_EMIT q->dsrChanged(false);
-        }
-    }
-    WaitCommEvent(Win_Handle, &eventMask, &overlap);
-}
-
-void QextSerialPortPrivate::updatePortSettings()
-{
-    if (!q_ptr->isOpen() || !settingsDirtyFlags)
-        return;
-
-    //fill struct : COMMCONFIG
-    if (settingsDirtyFlags & DFE_BaudRate) {
-        Win_CommConfig.dcb.BaudRate = Settings.BaudRate;
-    }
-    if (settingsDirtyFlags & DFE_Parity) {
-        Win_CommConfig.dcb.Parity = (BYTE)Settings.Parity;
-        Win_CommConfig.dcb.fParity = (Settings.Parity == QextSerialPort::PAR_NONE) ? FALSE : TRUE;
-    }
-    if (settingsDirtyFlags & DFE_DataBits) {
-        Win_CommConfig.dcb.ByteSize = (BYTE)Settings.DataBits;
-    }
-    if (settingsDirtyFlags & DFE_StopBits) {
-        switch (Settings.StopBits) {
-        case QextSerialPort::STOP_1:
-            Win_CommConfig.dcb.StopBits = ONESTOPBIT;
-            break;
-        case QextSerialPort::STOP_1_5:
-            Win_CommConfig.dcb.StopBits = ONE5STOPBITS;
-            break;
-        case QextSerialPort::STOP_2:
-            Win_CommConfig.dcb.StopBits = TWOSTOPBITS;
-            break;
-        }
-    }
-    if (settingsDirtyFlags & DFE_Flow) {
-        switch(Settings.FlowControl) {
-        /*no flow control*/
-        case QextSerialPort::FLOW_OFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
-            break;
-        /*software (XON/XOFF) flow control*/
-        case QextSerialPort::FLOW_XONXOFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=TRUE;
-            Win_CommConfig.dcb.fOutX=TRUE;
-            break;
-        /*hardware flow control*/
-        case QextSerialPort::FLOW_HARDWARE:
-            Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
-            break;
-        }
-    }
-
-    //fill struct : COMMTIMEOUTS
-    if (settingsDirtyFlags & DFE_TimeOut) {
-        int millisec = Settings.Timeout_Millisec;
-        if (millisec == -1) {
-            Win_CommTimeouts.ReadIntervalTimeout = MAXDWORD;
-            Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
-        } else {
-            Win_CommTimeouts.ReadIntervalTimeout = millisec;
-            Win_CommTimeouts.ReadTotalTimeoutConstant = millisec;
-        }
-        Win_CommTimeouts.ReadTotalTimeoutMultiplier = 0;
-        Win_CommTimeouts.WriteTotalTimeoutMultiplier = millisec;
-        Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
-    }
-
-
-    if (settingsDirtyFlags & DFE_Settings_Mask)
-        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
-    if ((settingsDirtyFlags & DFE_TimeOut))
-        SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
-    settingsDirtyFlags = 0;
-}

src/3rdparty/qextserialport/src/qextserialenumerator.cpp

 QextSerialEnumeratorPrivate::QextSerialEnumeratorPrivate(QextSerialEnumerator *enumrator)
     :q_ptr(enumrator)
 {
-    platformSpecificInit();
+    init_sys();
 }
 
 QextSerialEnumeratorPrivate::~QextSerialEnumeratorPrivate()
 {
-    platformSpecificDestruct();
+    destroy_sys();
 }
 
 /*!
     \bold Example
     \code
     QList<QextPortInfo> ports = QextSerialEnumerator::getPorts();
-    foreach( QextPortInfo port, ports ) {
+    foreach (QextPortInfo port, ports) {
         // inspect port...
     }
     \endcode
   
     \bold Example
     \code
-    QextSerialEnumerator* enumerator = new QextSerialEnumerator();
+    QextSerialEnumerator *enumerator = new QextSerialEnumerator();
     connect(enumerator, SIGNAL(deviceDiscovered(const QextPortInfo &)),
                myClass, SLOT(onDeviceDiscovered(const QextPortInfo &)));
     connect(enumerator, SIGNAL(deviceRemoved(const QextPortInfo &)),
 */
 
 /*!
-    \fn void QextSerialEnumerator::deviceDiscovered( const QextPortInfo & info )
+    \fn void QextSerialEnumerator::deviceDiscovered(const QextPortInfo &info)
     A new device has been connected to the system.
   
     setUpNotifications() must be called first to enable event-driven device notifications.
 */
 
 /*!
-   \fn void QextSerialEnumerator::deviceRemoved( const QextPortInfo & info );
+   \fn void QextSerialEnumerator::deviceRemoved(const QextPortInfo &info);
     A device has been disconnected from the system.
   
     setUpNotifications() must be called first to enable event-driven device notifications.
 QextSerialEnumerator::QextSerialEnumerator(QObject *parent)
     :QObject(parent), d_ptr(new QextSerialEnumeratorPrivate(this))
 {
-    if( !QMetaType::isRegistered( QMetaType::type("QextPortInfo") ) )
+    if (!QMetaType::isRegistered(QMetaType::type("QextPortInfo")))
         qRegisterMetaType<QextPortInfo>("QextPortInfo");
 }
 
 /*!
    Destructs the QextSerialEnumerator object.
 */
-QextSerialEnumerator::~QextSerialEnumerator( )
+QextSerialEnumerator::~QextSerialEnumerator()
 {
     delete d_ptr;
 }
 */
 QList<QextPortInfo> QextSerialEnumerator::getPorts()
 {
-#if defined(Q_OS_UNIX) && !defined(Q_OS_LINUX) && !defined(Q_OS_MAC)
-    qCritical("Enumeration for POSIX systems (except Linux) is not implemented yet.");
-#endif
     return QextSerialEnumeratorPrivate::getPorts_sys();
 }
 
 */
 void QextSerialEnumerator::setUpNotifications()
 {
-#if defined(Q_OS_UNIX) && !defined(Q_OS_MAC)
-    qCritical("Notifications for *Nix/FreeBSD are not implemented yet");
-#endif
     Q_D(QextSerialEnumerator);
     if (!d->setUpNotifications_sys(true))
         QESP_WARNING("Setup Notification Failed...");
 }
+
+#include "moc_qextserialenumerator.cpp"

src/3rdparty/qextserialport/src/qextserialenumerator.h

     Q_OBJECT
     Q_DECLARE_PRIVATE(QextSerialEnumerator)
 public:
-    QextSerialEnumerator(QObject * parent=0);
+    QextSerialEnumerator(QObject *parent=0);
     ~QextSerialEnumerator();
 
     static QList<QextPortInfo> getPorts();
     void setUpNotifications();
 
 Q_SIGNALS:
-    void deviceDiscovered(const QextPortInfo & info);
-    void deviceRemoved(const QextPortInfo & info);
+    void deviceDiscovered(const QextPortInfo &info);
+    void deviceRemoved(const QextPortInfo &info);
 
 private:
     Q_DISABLE_COPY(QextSerialEnumerator)
+#if defined(Q_OS_LINUX) && !defined(QESP_NO_UDEV)
+    Q_PRIVATE_SLOT(d_func(), void _q_deviceEvent())
+#endif
     QextSerialEnumeratorPrivate *d_ptr;
 };
 

src/3rdparty/qextserialport/src/qextserialenumerator_linux.cpp

+/****************************************************************************
+** Copyright (c) 2000-2003 Wayne Roth
+** Copyright (c) 2004-2007 Stefan Sander
+** Copyright (c) 2007 Michal Policht
+** Copyright (c) 2008 Brandon Fosdick
+** Copyright (c) 2009-2010 Liam Staskawicz
+** Copyright (c) 2011 Debao Zhang
+** Copyright (c) 2012 Doug Brown
+** All right reserved.
+** Web: http://code.google.com/p/qextserialport/
+**
+** Permission is hereby granted, free of charge, to any person obtaining
+** a copy of this software and associated documentation files (the
+** "Software"), to deal in the Software without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Software, and to
+** permit persons to whom the Software is furnished to do so, subject to
+** the following conditions:
+**
+** The above copyright notice and this permission notice shall be
+** included in all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+**
+****************************************************************************/
+
+#include "qextserialenumerator.h"
+#include "qextserialenumerator_p.h"
+#include <QtCore/QDebug>
+#include <QtCore/QStringList>
+#include <QtCore/QDir>
+
+void QextSerialEnumeratorPrivate::init_sys()
+{
+#ifndef QESP_NO_UDEV
+    monitor = NULL;
+    notifierFd = -1;
+    notifier = NULL;
+
+    udev = udev_new();
+    if (!udev)
+        qCritical() << "Unable to initialize udev notifications";
+#endif
+}
+
+void QextSerialEnumeratorPrivate::destroy_sys()
+{
+#ifndef QESP_NO_UDEV
+    if (notifier) {
+        notifier->setEnabled(false);
+        delete notifier;
+    }
+
+    if (monitor)
+        udev_monitor_unref(monitor);
+
+    if (udev)
+        udev_unref(udev);
+#endif
+}
+
+#ifndef QESP_NO_UDEV
+static QextPortInfo portInfoFromDevice(struct udev_device *dev)
+{
+    QString vendor = QString::fromLatin1(udev_device_get_property_value(dev, "ID_VENDOR_ID"));
+    QString product = QString::fromLatin1(udev_device_get_property_value(dev, "ID_MODEL_ID"));
+
+    QextPortInfo pi;
+    pi.vendorID = vendor.toInt(0, 16);
+    pi.productID = product.toInt(0, 16);
+    pi.portName = QString::fromLatin1(udev_device_get_devnode(dev));
+    pi.physName = pi.portName;
+
+    return pi;
+}
+#endif
+
+QList<QextPortInfo> QextSerialEnumeratorPrivate::getPorts_sys()
+{
+    QList<QextPortInfo> infoList;
+#ifndef QESP_NO_UDEV
+    struct udev *ud = udev_new();
+    if (!ud) {
+        qCritical() << "Unable to enumerate ports because udev is not initialized.";
+        return infoList;
+    }
+
+    struct udev_enumerate *enumerate = udev_enumerate_new(ud);
+    udev_enumerate_add_match_subsystem(enumerate, "tty");
+    udev_enumerate_scan_devices(enumerate);
+    struct udev_list_entry *list = udev_enumerate_get_list_entry(enumerate);
+    struct udev_list_entry *entry;
+    udev_list_entry_foreach(entry, list) {
+        const char *path;
+        struct udev_device *dev;
+
+        // Have to grab the actual udev device here...
+        path = udev_list_entry_get_name(entry);
+        dev = udev_device_new_from_syspath(ud, path);
+
+        infoList.append(portInfoFromDevice(dev));
+
+        // Done with this device
+        udev_device_unref(dev);
+    }
+    // Done with the list and this udev
+    udev_enumerate_unref(enumerate);
+    udev_unref(ud);
+#else
+    QStringList portNamePrefixes, portNameList;
+    portNamePrefixes << QLatin1String("ttyS*"); // list normal serial ports first
+
+    QDir dir(QLatin1String("/dev"));
+    portNameList = dir.entryList(portNamePrefixes, (QDir::System | QDir::Files), QDir::Name);
+
+    // remove the values which are not serial ports for e.g.  /dev/ttysa
+    for (int i = 0; i < portNameList.size(); i++) {
+        bool ok;
+        QString current = portNameList.at(i);
+        // remove the ttyS part, and check, if the other part is a number
+        current.remove(0,4).toInt(&ok, 10);
+        if (!ok) {
+            portNameList.removeAt(i);
+            i--;
+        }
+    }
+
+    // get the non standard serial ports names
+    // (USB-serial, bluetooth-serial, 18F PICs, and so on)
+    // if you know an other name prefix for serial ports please let us know
+    portNamePrefixes.clear();
+    portNamePrefixes << QLatin1String("ttyACM*") << QLatin1String("ttyUSB*") << QLatin1String("rfcomm*");
+    portNameList += dir.entryList(portNamePrefixes, (QDir::System | QDir::Files), QDir::Name);
+
+    foreach (QString str , portNameList) {
+        QextPortInfo inf;
+        inf.physName = QLatin1String("/dev/")+str;
+        inf.portName = str;
+
+        if (str.contains(QLatin1String("ttyS"))) {
+            inf.friendName = QLatin1String("Serial port ")+str.remove(0, 4);
+        }
+        else if (str.contains(QLatin1String("ttyUSB"))) {
+            inf.friendName = QLatin1String("USB-serial adapter ")+str.remove(0, 6);
+        }
+        else if (str.contains(QLatin1String("rfcomm"))) {
+            inf.friendName = QLatin1String("Bluetooth-serial adapter ")+str.remove(0, 6);
+        }
+        inf.enumName = QLatin1String("/dev"); // is there a more helpful name for this?
+        infoList.append(inf);
+    }
+#endif
+
+    return infoList;
+}
+
+bool QextSerialEnumeratorPrivate::setUpNotifications_sys(bool setup)
+{
+    Q_UNUSED(setup);
+#ifndef QESP_NO_UDEV
+    Q_Q(QextSerialEnumerator);
+    if (!udev) {
+        qCritical() << "Unable to initialize notifications because udev is not initialized.";
+        return false;
+    }
+
+    // Emit signals immediately for devices already connected (Windows version seems to behave
+    // this way)
+    foreach (QextPortInfo i, getPorts_sys())
+        Q_EMIT q->deviceDiscovered(i);
+
+    // Look for tty devices from udev.
+    monitor = udev_monitor_new_from_netlink(udev, "udev");
+    udev_monitor_filter_add_match_subsystem_devtype(monitor, "tty", NULL);
+    udev_monitor_enable_receiving(monitor);
+    notifierFd = udev_monitor_get_fd(monitor);
+    notifier = new QSocketNotifier(notifierFd, QSocketNotifier::Read);
+    q->connect(notifier, SIGNAL(activated(int)), q, SLOT(_q_deviceEvent()));
+    notifier->setEnabled(true);
+
+    return true;
+#else
+    return false;
+#endif
+}
+
+#ifndef QESP_NO_UDEV
+void QextSerialEnumeratorPrivate::_q_deviceEvent()
+{
+    Q_Q(QextSerialEnumerator);
+    struct udev_device *dev = udev_monitor_receive_device(monitor);
+    if (dev) {
+        QextPortInfo pi = portInfoFromDevice(dev);
+        QLatin1String action(udev_device_get_action(dev));
+
+        if (action == QLatin1String("add"))
+            Q_EMIT q->deviceDiscovered(pi);
+        else if (action == QLatin1String("remove"))
+            Q_EMIT q->deviceRemoved(pi);
+
+        udev_device_unref(dev);
+    }
+}
+#endif

src/3rdparty/qextserialport/src/qextserialenumerator_osx.cpp

 #include <CoreFoundation/CFNumber.h>
 #include <sys/param.h>
 
-void QextSerialEnumeratorPrivate::platformSpecificInit()
+void QextSerialEnumeratorPrivate::init_sys()
 {
 }
 
-void QextSerialEnumeratorPrivate::platformSpecificDestruct()
+void QextSerialEnumeratorPrivate::destroy_sys()
 {
-    IONotificationPortDestroy( notificationPortRef );
+    IONotificationPortDestroy(notificationPortRef);
 }
 
 // static
     CFMutableDictionaryRef matchingDictionary;
 
     // first try to get any serialbsd devices, then try any USBCDC devices
-    if( !(matchingDictionary = IOServiceMatching(kIOSerialBSDServiceValue) ) ) {
+    if (!(matchingDictionary = IOServiceMatching(kIOSerialBSDServiceValue))) {
         QESP_WARNING("IOServiceMatching returned a NULL dictionary.");
         return infoList;
     }
     CFDictionaryAddValue(matchingDictionary, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes));
 
     // then create the iterator with all the matching devices
-    if( IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &serialPortIterator) != KERN_SUCCESS ) {
+    if (IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &serialPortIterator) != KERN_SUCCESS) {
         qCritical() << "IOServiceGetMatchingServices failed, returned" << kernResult;
         return infoList;
     }
     IOObjectRelease(serialPortIterator);
     serialPortIterator = 0;
 
-    if( !(matchingDictionary = IOServiceNameMatching("AppleUSBCDC")) ) {
+    if (!(matchingDictionary = IOServiceNameMatching("AppleUSBCDC"))) {
         QESP_WARNING("IOServiceNameMatching returned a NULL dictionary.");
         return infoList;
     }
 
-    if( IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &serialPortIterator) != KERN_SUCCESS ) {
+    if (IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDictionary, &serialPortIterator) != KERN_SUCCESS) {
         qCritical() << "IOServiceGetMatchingServices failed, returned" << kernResult;
         return infoList;
     }
     return infoList;
 }
 
-void QextSerialEnumeratorPrivate::iterateServicesOSX(io_object_t service, QList<QextPortInfo> & infoList)
+void QextSerialEnumeratorPrivate::iterateServicesOSX(io_object_t service, QList<QextPortInfo> &infoList)
 {
     // Iterate through all modems found.
     io_object_t usbService;
-    while( ( usbService = IOIteratorNext(service) ) )
-    {
+    while ((usbService = IOIteratorNext(service))) {
         QextPortInfo info;
         info.vendorID = 0;
         info.productID = 0;
-        getServiceDetailsOSX( usbService, &info );
+        getServiceDetailsOSX(usbService, &info);
         infoList.append(info);
     }
 }
 
-bool QextSerialEnumeratorPrivate::getServiceDetailsOSX( io_object_t service, QextPortInfo* portInfo )
+bool QextSerialEnumeratorPrivate::getServiceDetailsOSX(io_object_t service, QextPortInfo *portInfo)
 {
     bool retval = true;
     CFTypeRef bsdPathAsCFString = NULL;
     // vendor/product IDs and the product name, if available
     io_registry_entry_t parent;
     kern_return_t kernResult = IORegistryEntryGetParentEntry(service, kIOServicePlane, &parent);
-    while( kernResult == KERN_SUCCESS && !vendorIdAsCFNumber && !productIdAsCFNumber )
-    {
-        if(!productNameAsCFString)
+    while (kernResult == KERN_SUCCESS && !vendorIdAsCFNumber && !productIdAsCFNumber) {
+        if (!productNameAsCFString)
             productNameAsCFString = IORegistryEntrySearchCFProperty(parent,
                                                                     kIOServicePlane,
                                                                     CFSTR("Product Name"),
     }
 
     io_string_t ioPathName;
-    IORegistryEntryGetPath( service, kIOServicePlane, ioPathName );
+    IORegistryEntryGetPath(service, kIOServicePlane, ioPathName);
     portInfo->physName = ioPathName;
 
-    if( bsdPathAsCFString )
-    {
+    if (bsdPathAsCFString) {
         char path[MAXPATHLEN];
-        if( CFStringGetCString((CFStringRef)bsdPathAsCFString, path,
-                               PATH_MAX, kCFStringEncodingUTF8) )
+        if (CFStringGetCString((CFStringRef)bsdPathAsCFString, path,
+                               PATH_MAX, kCFStringEncodingUTF8))
             portInfo->portName = path;
         CFRelease(bsdPathAsCFString);
     }
 
-    if(productNameAsCFString)
-    {
+    if (productNameAsCFString) {
         char productName[MAXPATHLEN];
-        if( CFStringGetCString((CFStringRef)productNameAsCFString, productName,
-                               PATH_MAX, kCFStringEncodingUTF8) )
+        if (CFStringGetCString((CFStringRef)productNameAsCFString, productName,
+                               PATH_MAX, kCFStringEncodingUTF8))
             portInfo->friendName = productName;
         CFRelease(productNameAsCFString);
     }
 
-    if(vendorIdAsCFNumber)
-    {
+    if (vendorIdAsCFNumber) {
         SInt32 vID;
-        if(CFNumberGetValue((CFNumberRef)vendorIdAsCFNumber, kCFNumberSInt32Type, &vID))
+        if (CFNumberGetValue((CFNumberRef)vendorIdAsCFNumber, kCFNumberSInt32Type, &vID))
             portInfo->vendorID = vID;
         CFRelease(vendorIdAsCFNumber);
     }
 
-    if(productIdAsCFNumber)
-    {
+    if (productIdAsCFNumber) {
         SInt32 pID;
-        if(CFNumberGetValue((CFNumberRef)productIdAsCFNumber, kCFNumberSInt32Type, &pID))
+        if (CFNumberGetValue((CFNumberRef)productIdAsCFNumber, kCFNumberSInt32Type, &pID))
             portInfo->productID = pID;
         CFRelease(productIdAsCFNumber);
     }
 }
 
 // IOKit callbacks registered via setupNotifications()
-void deviceDiscoveredCallbackOSX( void *ctxt, io_iterator_t serialPortIterator )
+void deviceDiscoveredCallbackOSX(void *ctxt, io_iterator_t serialPortIterator)
 {
-    QextSerialEnumeratorPrivate* d = (QextSerialEnumeratorPrivate*)ctxt;
+    QextSerialEnumeratorPrivate *d = (QextSerialEnumeratorPrivate *)ctxt;
     io_object_t serialService;
     while ((serialService = IOIteratorNext(serialPortIterator)))
         d->onDeviceDiscoveredOSX(serialService);
 }
 
-void deviceTerminatedCallbackOSX( void *ctxt, io_iterator_t serialPortIterator )
+void deviceTerminatedCallbackOSX(void *ctxt, io_iterator_t serialPortIterator)
 {
-    QextSerialEnumeratorPrivate* d = (QextSerialEnumeratorPrivate*)ctxt;
+    QextSerialEnumeratorPrivate *d = (QextSerialEnumeratorPrivate *)ctxt;
     io_object_t serialService;
     while ((serialService = IOIteratorNext(serialPortIterator)))
         d->onDeviceTerminatedOSX(serialService);
   A device has been discovered via IOKit.
   Create a QextPortInfo if possible, and emit the signal indicating that we've found it.
 */
-void QextSerialEnumeratorPrivate::onDeviceDiscoveredOSX( io_object_t service )
+void QextSerialEnumeratorPrivate::onDeviceDiscoveredOSX(io_object_t service)
 {
     Q_Q(QextSerialEnumerator);
     QextPortInfo info;
     info.vendorID = 0;
     info.productID = 0;
-    if( getServiceDetailsOSX( service, &info ) )
-        Q_EMIT q->deviceDiscovered( info );
+    if (getServiceDetailsOSX(service, &info))
+        Q_EMIT q->deviceDiscovered(info);
 }
 
 /*
   Notification via IOKit that a device has been removed.
   Create a QextPortInfo if possible, and emit the signal indicating that it's gone.
 */
-void QextSerialEnumeratorPrivate::onDeviceTerminatedOSX( io_object_t service )
+void QextSerialEnumeratorPrivate::onDeviceTerminatedOSX(io_object_t service)
 {
     Q_Q(QextSerialEnumerator);
     QextPortInfo info;
     info.vendorID = 0;
     info.productID = 0;
-    if( getServiceDetailsOSX( service, &info ) )
-        Q_EMIT q->deviceRemoved( info );
+    if (getServiceDetailsOSX(service, &info))
+        Q_EMIT q->deviceRemoved(info);
 }
 
 /*
   to these notifications once to arm them, and discover any devices that
   are currently connected at the time notifications are setup.
 */
-bool QextSerialEnumeratorPrivate::setUpNotifications_sys(bool setup)
+bool QextSerialEnumeratorPrivate::setUpNotifications_sys(bool /*setup*/)
 {
     kern_return_t kernResult;
     mach_port_t masterPort;
     else
         CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes));
 
-    if( !(cdcClassesToMatch = IOServiceNameMatching("AppleUSBCDC") ) ) {
+    if (!(cdcClassesToMatch = IOServiceNameMatching("AppleUSBCDC"))) {
         QESP_WARNING("couldn't create cdc matching dict");
         return false;
     }
     cdcClassesToMatch = (CFMutableDictionaryRef) CFRetain(cdcClassesToMatch);
 
     notificationPortRef = IONotificationPortCreate(masterPort);
-    if(notificationPortRef == NULL) {
+    if (notificationPortRef == NULL) {
         qDebug("IONotificationPortCreate return a NULL IONotificationPortRef.");
         return false;
     }
     }
 
     // arm the callback, and grab any devices that are already connected
-    deviceDiscoveredCallbackOSX( this, portIterator );
+    deviceDiscoveredCallbackOSX(this, portIterator);
 
     kernResult = IOServiceAddMatchingNotification(notificationPortRef, kIOMatchedNotification, cdcClassesToMatch,
                                                   deviceDiscoveredCallbackOSX, this, &portIterator);
     }
 
     // arm the callback, and grab any devices that are already connected
-    deviceDiscoveredCallbackOSX( this, portIterator );
+    deviceDiscoveredCallbackOSX(this, portIterator);
 
     kernResult = IOServiceAddMatchingNotification(notificationPortRef, kIOTerminatedNotification, classesToMatch,
                                                   deviceTerminatedCallbackOSX, this, &portIterator);
     }
 
     // arm the callback, and clear any devices that are terminated
-    deviceTerminatedCallbackOSX( this, portIterator );
+    deviceTerminatedCallbackOSX(this, portIterator);
 
     kernResult = IOServiceAddMatchingNotification(notificationPortRef, kIOTerminatedNotification, cdcClassesToMatch,
                                                   deviceTerminatedCallbackOSX, this, &portIterator);
     }
 
     // arm the callback, and clear any devices that are terminated
-    deviceTerminatedCallbackOSX( this, portIterator );
+    deviceTerminatedCallbackOSX(this, portIterator);
     return true;
 }
 

src/3rdparty/qextserialport/src/qextserialenumerator_p.h

 ** Copyright (c) 2008 Brandon Fosdick
 ** Copyright (c) 2009-2010 Liam Staskawicz
 ** Copyright (c) 2011 Debao Zhang
+** Copyright (c) 2012 Doug Brown
 ** All right reserved.
 ** Web: http://code.google.com/p/qextserialport/
 **
 
 #include "qextserialenumerator.h"
 
-#ifdef Q_OS_WIN
+#ifdef  Q_CC_MINGW
 // needed for mingw to pull in appropriate dbt business...
 // probably a better way to do this
 // http://mingw-users.1079350.n2.nabble.com/DEV-BROADCAST-DEVICEINTERFACE-was-not-declared-in-this-scope-td3552762.html
-#  ifdef  __MINGW32__
-#    define _WIN32_WINNT 0x0500
-#    define _WIN32_WINDOWS 0x0500
-#    define WINVER 0x0500
+// http://msdn.microsoft.com/en-us/library/6sehtctf.aspx
+#  ifndef WINVER
+#    define WINVER 0x0501
+#  endif
+#  ifndef _WIN32_WINNT
+#    define _WIN32_WINNT WINVER
 #  endif
+#endif
+
+#ifdef Q_OS_WIN
 #  include <QtCore/qt_windows.h>
 #endif /*Q_OS_WIN*/
 
 #  include <IOKit/usb/IOUSBLib.h>
 #endif /*Q_OS_MAC*/
 
+#if defined(Q_OS_LINUX) && !defined(QESP_NO_UDEV)
+#  include <QSocketNotifier>
+extern "C" {
+#  include <libudev.h>
+}
+#endif
+
 class QextSerialRegistrationWidget;
 class QextSerialEnumeratorPrivate
 {
     Q_DECLARE_PUBLIC(QextSerialEnumerator)
 public:
-    QextSerialEnumeratorPrivate(QextSerialEnumerator * enumrator);
+    QextSerialEnumeratorPrivate(QextSerialEnumerator *enumrator);
     ~QextSerialEnumeratorPrivate();
-    void platformSpecificInit();
-    void platformSpecificDestruct();
+    void init_sys();
+    void destroy_sys();
 
     static QList<QextPortInfo> getPorts_sys();
     bool setUpNotifications_sys(bool setup);
 
-#ifdef Q_OS_WIN
-    LRESULT onDeviceChanged( WPARAM wParam, LPARAM lParam );
-    bool matchAndDispatchChangedDevice(const QString & deviceID, const GUID & guid, WPARAM wParam);
-#  ifdef QT_GUI_LIB
-    QextSerialRegistrationWidget* notificationWidget;
-#  endif
+#if defined(Q_OS_WIN) && defined(QT_GUI_LIB)
+    LRESULT onDeviceChanged(WPARAM wParam, LPARAM lParam);
+    bool matchAndDispatchChangedDevice(const QString &deviceID, const GUID &guid, WPARAM wParam);
+    QextSerialRegistrationWidget *notificationWidget;
 #endif /*Q_OS_WIN*/
 
 #ifdef Q_OS_MAC
      * Search for serial ports using IOKit.
      *    \param infoList list with result.
      */
-    static void iterateServicesOSX(io_object_t service, QList<QextPortInfo> & infoList);
-    static bool getServiceDetailsOSX( io_object_t service, QextPortInfo* portInfo );
-    void onDeviceDiscoveredOSX( io_object_t service );
-    void onDeviceTerminatedOSX( io_object_t service );
-    friend void deviceDiscoveredCallbackOSX( void *ctxt, io_iterator_t serialPortIterator );
-    friend void deviceTerminatedCallbackOSX( void *ctxt, io_iterator_t serialPortIterator );
+    static void iterateServicesOSX(io_object_t service, QList<QextPortInfo> &infoList);
+    static bool getServiceDetailsOSX(io_object_t service, QextPortInfo *portInfo);
+    void onDeviceDiscoveredOSX(io_object_t service);
+    void onDeviceTerminatedOSX(io_object_t service);
+    friend void deviceDiscoveredCallbackOSX(void *ctxt, io_iterator_t serialPortIterator);
+    friend void deviceTerminatedCallbackOSX(void *ctxt, io_iterator_t serialPortIterator);
 
     IONotificationPortRef notificationPortRef;
 #endif // Q_OS_MAC
 
+#if defined(Q_OS_LINUX) && !defined(QESP_NO_UDEV)
+    QSocketNotifier *notifier;
+    int notifierFd;
+    struct udev *udev;
+    struct udev_monitor *monitor;
+
+    void _q_deviceEvent();
+#endif
+
 private:
-    QextSerialEnumerator * q_ptr;
+    QextSerialEnumerator *q_ptr;
 };
 
 #endif //_QEXTSERIALENUMERATOR_P_H_

src/3rdparty/qextserialport/src/qextserialenumerator_unix.cpp

 #include "qextserialenumerator.h"
 #include "qextserialenumerator_p.h"
 #include <QtCore/QDebug>
-#include <QtCore/QStringList>
-#include <QtCore/QDir>
 
-void QextSerialEnumeratorPrivate::platformSpecificInit()
+void QextSerialEnumeratorPrivate::init_sys()
 {
 }
 
-void QextSerialEnumeratorPrivate::platformSpecificDestruct()
+void QextSerialEnumeratorPrivate::destroy_sys()
 {
 }
 
 QList<QextPortInfo> QextSerialEnumeratorPrivate::getPorts_sys()
 {
     QList<QextPortInfo> infoList;
-#ifdef Q_OS_LINUX
-    QStringList portNamePrefixes, portNameList;
-    portNamePrefixes << QLatin1String("ttyS*"); // list normal serial ports first
-
-    QDir dir(QLatin1String("/dev"));
-    portNameList = dir.entryList(portNamePrefixes, (QDir::System | QDir::Files), QDir::Name);
-
-    // remove the values which are not serial ports for e.g.  /dev/ttysa
-    for (int i = 0; i < portNameList.size(); i++) {
-        bool ok;
-        QString current = portNameList.at(i);
-        // remove the ttyS part, and check, if the other part is a number
-        current.remove(0,4).toInt(&ok, 10);
-        if (!ok) {
-            portNameList.removeAt(i);
-            i--;
-        }
-    }
-
-    // get the non standard serial ports names
-    // (USB-serial, bluetooth-serial, 18F PICs, and so on)
-    // if you know an other name prefix for serial ports please let us know
-    portNamePrefixes.clear();
-    portNamePrefixes << QLatin1String("ttyACM*") << QLatin1String("ttyUSB*") << QLatin1String("rfcomm*");
-    portNameList += dir.entryList(portNamePrefixes, (QDir::System | QDir::Files), QDir::Name);
-
-    foreach (QString str , portNameList) {
-        QextPortInfo inf;
-        inf.physName = QLatin1String("/dev/")+str;
-        inf.portName = str;
-
-        if (str.contains(QLatin1String("ttyS"))) {
-            inf.friendName = QLatin1String("Serial port ")+str.remove(0, 4);
-        }
-        else if (str.contains(QLatin1String("ttyUSB"))) {
-            inf.friendName = QLatin1String("USB-serial adapter ")+str.remove(0, 6);
-        }
-        else if (str.contains(QLatin1String("rfcomm"))) {
-            inf.friendName = QLatin1String("Bluetooth-serial adapter ")+str.remove(0, 6);
-        }
-        inf.enumName = QLatin1String("/dev"); // is there a more helpful name for this?
-        infoList.append(inf);
-    }
-#endif
+    QESP_WARNING("Enumeration for POSIX systems (except Linux) is not implemented yet.");
     return infoList;
 }
 
 bool QextSerialEnumeratorPrivate::setUpNotifications_sys(bool setup)
 {
     Q_UNUSED(setup)
+    QESP_WARNING("Notifications for *Nix/FreeBSD are not implemented yet");
     return false;
 }

src/3rdparty/qextserialport/src/qextserialenumerator_win.cpp

 #include <QtCore/QDebug>
 #include <QtCore/QMetaType>
 #include <QtCore/QRegExp>
+#include <algorithm>
 #include <objbase.h>
 #include <initguid.h>
 #include <setupapi.h>
 #include <dbt.h>
-#include "qextserialport.h"
 
 #ifdef QT_GUI_LIB
+/*!
+  \internal
+  \class QextSerialRegistrationWidget
+
+  Internal window which is used to receive device arrvial and removal message.
+*/
+
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
 #include <QtGui/QWidget>
 class QextSerialRegistrationWidget : public QWidget
 #endif
 {
 public:
-    QextSerialRegistrationWidget(QextSerialEnumeratorPrivate* qese) {
+    QextSerialRegistrationWidget(QextSerialEnumeratorPrivate *qese) {
         this->qese = qese;
     }
     ~QextSerialRegistrationWidget() {}
 protected:
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-    bool winEvent( MSG* message, long* result ) {
+    bool winEvent(MSG *message, long *result) {
 #else
     bool nativeEvent(const QByteArray & /*eventType*/, void *msg, long *result) {
-        MSG *message = static_cast<MSG*>(msg);
+        MSG *message = static_cast<MSG *>(msg);
 #endif
-        if ( message->message == WM_DEVICECHANGE ) {
-            qese->onDeviceChanged(message->wParam, message->lParam );
+        if (message->message == WM_DEVICECHANGE) {
+            qese->onDeviceChanged(message->wParam, message->lParam);
             *result = 1;
             return true;
         }
         return false;
     }
 private:
-    QextSerialEnumeratorPrivate* qese;
+    QextSerialEnumeratorPrivate *qese;
 };
-
 #endif // QT_GUI_LIB
 
-void QextSerialEnumeratorPrivate::platformSpecificInit()
+void QextSerialEnumeratorPrivate::init_sys()
 {
 #ifdef QT_GUI_LIB
     notificationWidget = 0;
 /*!
   default
 */
-void QextSerialEnumeratorPrivate::platformSpecificDestruct()
+void QextSerialEnumeratorPrivate::destroy_sys()
 {
 #ifdef QT_GUI_LIB
-    if( notificationWidget )
+    if (notificationWidget)
         delete notificationWidget;
 #endif
 }
 
-// see http://msdn.microsoft.com/en-us/library/windows/hardware/ff553426(v=vs.85).aspx
-// for list of GUID classes
-#ifndef GUID_DEVCLASS_PORTS
-    DEFINE_GUID(GUID_DEVCLASS_PORTS, 0x4D36E978, 0xE325, 0x11CE, 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18 );
+#ifndef GUID_DEVINTERFACE_COMPORT
+DEFINE_GUID(GUID_DEVINTERFACE_COMPORT, 0x86e0d1e0L, 0x8089, 0x11d0, 0x9c, 0xe4, 0x08, 0x00, 0x3e, 0x30, 0x1f, 0x73);
 #endif
 
-/* Gordon Schumacher's macros for TCHAR -> QString conversions and vice versa */
-#ifdef UNICODE
-    #define QStringToTCHAR(x)     (wchar_t*) x.utf16()
-    #define PQStringToTCHAR(x)    (wchar_t*) x->utf16()
-    #define TCHARToQString(x)     QString::fromUtf16((ushort*)(x))
-    #define TCHARToQStringN(x,y)  QString::fromUtf16((ushort*)(x),(y))
-#else
-    #define QStringToTCHAR(x)     x.local8Bit().constData()
-    #define PQStringToTCHAR(x)    x->local8Bit().constData()
-    #define TCHARToQString(x)     QString::fromLocal8Bit((char*)(x))
-    #define TCHARToQStringN(x,y)  QString::fromLocal8Bit((char*)(x),(y))
-#endif /*UNICODE*/
 
 /*!
     \internal
 {
     DWORD size = 0;
     DWORD type;
-    ::RegQueryValueEx(key, property, NULL, NULL, NULL, & size);
-    BYTE* buff = new BYTE[size];
+    if (::RegQueryValueEx(key, property, NULL, NULL, NULL, &size) != ERROR_SUCCESS)
+        return QString();
+    BYTE *buff = new BYTE[size];
     QString result;
-    if(::RegQueryValueEx(key, property, NULL, &type, buff, & size) == ERROR_SUCCESS )
-        result = TCHARToQString(buff);
-    ::RegCloseKey(key);
+    if (::RegQueryValueEx(key, property, NULL, &type, buff, &size) == ERROR_SUCCESS)
+        result = QString::fromUtf16(reinterpret_cast<ushort *>(buff));
     delete [] buff;
     return result;
 }
 /*!
      \internal
      Get specific property from registry.
-     \a devInfo pointer to the device information set that contains the interface
+     \a devInfoSet pointer to the device information set that contains the interface
         and its underlying device. Returned by SetupDiGetClassDevs() function.
-     \a devData pointer to an SP_DEVINFO_DATA structure that defines the device instance.
+     \a devInfoData pointer to an SP_DEVINFO_DATA structure that defines the device instance.
         this is returned by SetupDiGetDeviceInterfaceDetail() function.
      \a property registry property. One of defined SPDRP_* constants.
 
      return property string.
  */
-static QString getDeviceProperty(HDEVINFO devInfo, PSP_DEVINFO_DATA devData, DWORD property)
+static QString getDeviceRegistryProperty(HDEVINFO devInfoSet, PSP_DEVINFO_DATA devInfoData, DWORD property)
 {
     DWORD buffSize = 0;
-    ::SetupDiGetDeviceRegistryProperty(devInfo, devData, property, NULL, NULL, 0, & buffSize);
-    BYTE* buff = new BYTE[buffSize];
-    ::SetupDiGetDeviceRegistryProperty(devInfo, devData, property, NULL, buff, buffSize, NULL);
-    QString result = TCHARToQString(buff);
+    ::SetupDiGetDeviceRegistryProperty(devInfoSet, devInfoData, property, NULL, NULL, 0, &buffSize);
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+        return QString();
+    BYTE *buff = new BYTE[buffSize];
+    ::SetupDiGetDeviceRegistryProperty(devInfoSet, devInfoData, property, NULL, buff, buffSize, NULL);
+    QString result = QString::fromUtf16(reinterpret_cast<ushort *>(buff));
     delete [] buff;
     return result;
 }
 /*!
      \internal
 */
-static bool getDeviceDetailsWin( QextPortInfo* portInfo, HDEVINFO devInfo, PSP_DEVINFO_DATA devData
+static bool getDeviceDetailsInformation(QextPortInfo *portInfo, HDEVINFO devInfoSet, PSP_DEVINFO_DATA devInfoData
                                  , WPARAM wParam = DBT_DEVICEARRIVAL)
 {
-    portInfo->friendName = getDeviceProperty(devInfo, devData, SPDRP_FRIENDLYNAME);
-    if( wParam == DBT_DEVICEARRIVAL)
-        portInfo->physName = getDeviceProperty(devInfo, devData, SPDRP_PHYSICAL_DEVICE_OBJECT_NAME);
-    portInfo->enumName = getDeviceProperty(devInfo, devData, SPDRP_ENUMERATOR_NAME);
-    QString hardwareIDs = getDeviceProperty(devInfo, devData, SPDRP_HARDWAREID);
-    HKEY devKey = ::SetupDiOpenDevRegKey(devInfo, devData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
+    portInfo->friendName = getDeviceRegistryProperty(devInfoSet, devInfoData, SPDRP_FRIENDLYNAME);
+    if (wParam == DBT_DEVICEARRIVAL)
+        portInfo->physName = getDeviceRegistryProperty(devInfoSet, devInfoData, SPDRP_PHYSICAL_DEVICE_OBJECT_NAME);
+    portInfo->enumName = getDeviceRegistryProperty(devInfoSet, devInfoData, SPDRP_ENUMERATOR_NAME);
+
+    HKEY devKey = ::SetupDiOpenDevRegKey(devInfoSet, devInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
     portInfo->portName = getRegKeyValue(devKey, TEXT("PortName"));
+    ::RegCloseKey(devKey);
+
+    QString hardwareIDs = getDeviceRegistryProperty(devInfoSet, devInfoData, SPDRP_HARDWAREID);
     QRegExp idRx(QLatin1String("VID_(\\w+)&PID_(\\w+)"));
-    if(hardwareIDs.toUpper().contains(idRx)) {
+    if (hardwareIDs.toUpper().contains(idRx)) {
         bool dummy;
         portInfo->vendorID = idRx.cap(1).toInt(&dummy, 16);
         portInfo->productID = idRx.cap(2).toInt(&dummy, 16);
 /*!
      \internal
 */
-static void enumerateDevicesWin( const GUID & guid, QList<QextPortInfo>* infoList )
+static void enumerateDevices(const GUID &guid, QList<QextPortInfo> *infoList)
 {
-    HDEVINFO devInfo;
-    if( (devInfo = ::SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT)) != INVALID_HANDLE_VALUE) {
+    HDEVINFO devInfoSet = ::SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+    if (devInfoSet != INVALID_HANDLE_VALUE) {
         SP_DEVINFO_DATA devInfoData;
         devInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
-        for(int i = 0; ::SetupDiEnumDeviceInfo(devInfo, i, &devInfoData); i++) {
+        for(int i = 0; ::SetupDiEnumDeviceInfo(devInfoSet, i, &devInfoData); i++) {
             QextPortInfo info;
             info.productID = info.vendorID = 0;
-            getDeviceDetailsWin( &info, devInfo, &devInfoData );
+            getDeviceDetailsInformation(&info, devInfoSet, &devInfoData);
             infoList->append(info);
         }
-        ::SetupDiDestroyDeviceInfoList(devInfo);
+        ::SetupDiDestroyDeviceInfoList(devInfoSet);
     }
 }
 
 QList<QextPortInfo> QextSerialEnumeratorPrivate::getPorts_sys()
 {
     QList<QextPortInfo> ports;
-    enumerateDevicesWin(GUID_DEVCLASS_PORTS, &ports);
-    qSort(ports.begin(), ports.end(), lessThan);
+    enumerateDevices(GUID_DEVINTERFACE_COMPORT, &ports);
+    std::sort(ports.begin(), ports.end(), lessThan);
     return ports;
 }
 
     return false;
 #else
     Q_Q(QextSerialEnumerator);
-    if(setup && notificationWidget) //already setup
+    if (setup && notificationWidget) //already setup
         return true;
     notificationWidget = new QextSerialRegistrationWidget(this);
 
     ::ZeroMemory(&dbh, sizeof(dbh));
     dbh.dbcc_size = sizeof(dbh);
     dbh.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
-    ::CopyMemory(&dbh.dbcc_classguid, &GUID_DEVCLASS_PORTS, sizeof(GUID));
-    if(::RegisterDeviceNotification((HWND)notificationWidget->winId(), &dbh, DEVICE_NOTIFY_WINDOW_HANDLE ) == NULL) {
+    // dbh.dbcc_classguid = GUID_DEVCLASS_PORTS; //Ignored in such case
+    DWORD flags = DEVICE_NOTIFY_WINDOW_HANDLE|DEVICE_NOTIFY_ALL_INTERFACE_CLASSES;
+    if (::RegisterDeviceNotification((HWND)notificationWidget->winId(), &dbh, flags) == NULL) {
         QESP_WARNING() << "RegisterDeviceNotification failed:" << GetLastError();
         return false;
     }
     // setting up notifications doesn't tell us about devices already connected
     // so get those manually
-    foreach(QextPortInfo port, getPorts_sys())
-      Q_EMIT q->deviceDiscovered(port);
+    foreach (QextPortInfo port, getPorts_sys())
+        Q_EMIT q->deviceDiscovered(port);
     return true;
 #endif // QT_GUI_LIB
 }
 
-LRESULT QextSerialEnumeratorPrivate::onDeviceChanged( WPARAM wParam, LPARAM lParam )
+#ifdef QT_GUI_LIB
+LRESULT QextSerialEnumeratorPrivate::onDeviceChanged(WPARAM wParam, LPARAM lParam)
 {
-    if (DBT_DEVICEARRIVAL == wParam || DBT_DEVICEREMOVECOMPLETE == wParam ) {
+    if (DBT_DEVICEARRIVAL == wParam || DBT_DEVICEREMOVECOMPLETE == wParam) {
         PDEV_BROADCAST_HDR pHdr = (PDEV_BROADCAST_HDR)lParam;
-        if(pHdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE ) {
+        if (pHdr->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
             PDEV_BROADCAST_DEVICEINTERFACE pDevInf = (PDEV_BROADCAST_DEVICEINTERFACE)pHdr;
              // delimiters are different across APIs...change to backslash.  ugh.
-            QString deviceID = TCHARToQString(pDevInf->dbcc_name).toUpper().replace(QLatin1String("#"), QLatin1String("\\"));
+            QString deviceID = QString::fromUtf16(reinterpret_cast<ushort *>(pDevInf->dbcc_name));
+            deviceID = deviceID.toUpper().replace(QLatin1String("#"), QLatin1String("\\"));
 
-            matchAndDispatchChangedDevice(deviceID, GUID_DEVCLASS_PORTS, wParam);
+            matchAndDispatchChangedDevice(deviceID, GUID_DEVINTERFACE_COMPORT, wParam);
         }
     }
     return 0;
 }
 
-bool QextSerialEnumeratorPrivate::matchAndDispatchChangedDevice(const QString & deviceID, const GUID & guid, WPARAM wParam)
+bool QextSerialEnumeratorPrivate::matchAndDispatchChangedDevice(const QString &deviceID, const GUID &guid, WPARAM wParam)
 {
     Q_Q(QextSerialEnumerator);
     bool rv = false;
-    DWORD dwFlag = (DBT_DEVICEARRIVAL == wParam) ? DIGCF_PRESENT : DIGCF_ALLCLASSES;
-    HDEVINFO devInfo;
-    if( (devInfo = SetupDiGetClassDevs(&guid,NULL,NULL,dwFlag)) != INVALID_HANDLE_VALUE ) {
+    DWORD dwFlag = (DBT_DEVICEARRIVAL == wParam) ? DIGCF_PRESENT : DIGCF_PROFILE;
+    HDEVINFO devInfoSet  = SetupDiGetClassDevs(&guid, NULL, NULL, dwFlag | DIGCF_DEVICEINTERFACE);
+    if (devInfoSet != INVALID_HANDLE_VALUE) {
         SP_DEVINFO_DATA spDevInfoData;
         spDevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
-        for(int i=0; SetupDiEnumDeviceInfo(devInfo, i, &spDevInfoData); i++) {
-            DWORD nSize=0 ;
+        for(int i=0; SetupDiEnumDeviceInfo(devInfoSet, i, &spDevInfoData); i++) {
+            DWORD nSize = 0;
             TCHAR buf[MAX_PATH];
-            if ( SetupDiGetDeviceInstanceId(devInfo, &spDevInfoData, buf, MAX_PATH, &nSize) &&
-                    deviceID.contains(TCHARToQString(buf))) { // we found a match
+            if (SetupDiGetDeviceInstanceId(devInfoSet, &spDevInfoData, buf, MAX_PATH, &nSize)
+                    && deviceID.contains(QString::fromUtf16(reinterpret_cast<ushort *>(buf)))) { // we found a match
                 rv = true;
                 QextPortInfo info;
                 info.productID = info.vendorID = 0;
-                getDeviceDetailsWin( &info, devInfo, &spDevInfoData, wParam );
-                if( wParam == DBT_DEVICEARRIVAL )
+                getDeviceDetailsInformation(&info, devInfoSet, &spDevInfoData, wParam);
+                if (wParam == DBT_DEVICEARRIVAL)
                     Q_EMIT q->deviceDiscovered(info);
-                else if( wParam == DBT_DEVICEREMOVECOMPLETE )
+                else if (wParam == DBT_DEVICEREMOVECOMPLETE)
                     Q_EMIT q->deviceRemoved(info);
                 break;
             }
         }
-        SetupDiDestroyDeviceInfoList(devInfo);
+        SetupDiDestroyDeviceInfoList(devInfoSet);
     }
     return rv;
 }
+#endif //QT_GUI_LIB

src/3rdparty/qextserialport/src/qextserialport.cpp

     :lock(QReadWriteLock::Recursive), q_ptr(q)
 {
     lastErr = E_NO_ERROR;
-    Settings.BaudRate = BAUD9600;
-    Settings.Parity = PAR_NONE;
-    Settings.FlowControl = FLOW_OFF;
-    Settings.DataBits = DATA_8;
-    Settings.StopBits = STOP_1;
-    Settings.Timeout_Millisec = 10;
+    settings.BaudRate = BAUD9600;
+    settings.Parity = PAR_NONE;
+    settings.FlowControl = FLOW_OFF;
+    settings.DataBits = DATA_8;
+    settings.StopBits = STOP_1;
+    settings.Timeout_Millisec = 10;
     settingsDirtyFlags = DFE_ALL;
 
     platformSpecificInit();
     case BAUD150:
     case BAUD200:
     case BAUD1800:
-#ifdef B76800
+#  ifdef B76800
     case BAUD76800:
-#endif
-#if defined(B230400) && defined(B4000000)
+#  endif
+#  if defined(B230400) && defined(B4000000)
     case BAUD230400:
     case BAUD460800:
     case BAUD500000:
     case BAUD3000000:
     case BAUD3500000:
     case BAUD4000000:
-#endif
+#  endif
         QESP_PORTABILITY_WARNING()<<"QextSerialPort Portability Warning: Windows does not support baudRate:"<<baudRate;
 #endif
     case BAUD110:
     case BAUD38400:
     case BAUD57600:
     case BAUD115200:
-        Settings.BaudRate=baudRate;
+#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
+    default:
+#endif
+        settings.BaudRate = baudRate;
         settingsDirtyFlags |= DFE_BaudRate;
         if (update && q_func()->isOpen())
             updatePortSettings();
         break;
+#if !(defined(Q_OS_WIN) || defined(Q_OS_MAC))
     default:
         QESP_WARNING()<<"QextSerialPort does not support baudRate:"<<baudRate;
+#endif
     }
 }
 
 {
     switch (parity) {
     case PAR_SPACE:
-        if (Settings.DataBits==DATA_8) {
+        if (settings.DataBits == DATA_8) {
 #ifdef Q_OS_WIN
             QESP_PORTABILITY_WARNING("QextSerialPort Portability Warning: Space parity with 8 data bits is not supported by POSIX systems.");
 #else
         QESP_WARNING()<<"QextSerialPort does not support Parity:" << parity;
     }
 
-    Settings.Parity=parity;
+    settings.Parity = parity;
     settingsDirtyFlags |= DFE_Parity;
     if (update && q_func()->isOpen())
         updatePortSettings();
     switch(dataBits) {
 
     case DATA_5:
-        if (Settings.StopBits==STOP_2) {
+        if (settings.StopBits == STOP_2) {
             QESP_WARNING("QextSerialPort: 5 Data bits cannot be used with 2 stop bits.");
-        }
-        else {
-            Settings.DataBits=dataBits;
+        } else {
+            settings.DataBits = dataBits;
             settingsDirtyFlags |= DFE_DataBits;
         }
         break;
 
     case DATA_6:
 #ifdef Q_OS_WIN
-        if (Settings.StopBits==STOP_1_5) {
+        if (settings.StopBits == STOP_1_5) {
             QESP_WARNING("QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits.");
         }
         else
 #endif
         {
-            Settings.DataBits=dataBits;
+            settings.DataBits = dataBits;
             settingsDirtyFlags |= DFE_DataBits;
         }
         break;
 
     case DATA_7:
 #ifdef Q_OS_WIN
-        if (Settings.StopBits==STOP_1_5) {
+        if (settings.StopBits == STOP_1_5) {
             QESP_WARNING("QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits.");
         }
         else
 #endif
         {
-            Settings.DataBits=dataBits;
+            settings.DataBits = dataBits;
             settingsDirtyFlags |= DFE_DataBits;
         }
         break;
 
     case DATA_8:
 #ifdef Q_OS_WIN
-        if (Settings.StopBits==STOP_1_5) {
+        if (settings.StopBits == STOP_1_5) {
             QESP_WARNING("QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits.");
         }
         else
 #endif
         {
-            Settings.DataBits=dataBits;
+            settings.DataBits = dataBits;
             settingsDirtyFlags |= DFE_DataBits;
         }
         break;
 
         /*one stop bit*/
     case STOP_1:
-        Settings.StopBits = stopBits;
+        settings.StopBits = stopBits;
         settingsDirtyFlags |= DFE_StopBits;
         break;
 
         /*1.5 stop bits*/
     case STOP_1_5:
         QESP_PORTABILITY_WARNING("QextSerialPort Portability Warning: 1.5 stop bit operation is not supported by POSIX.");
-        if (Settings.DataBits!=DATA_5) {
+        if (settings.DataBits != DATA_5) {
             QESP_WARNING("QextSerialPort: 1.5 stop bits can only be used with 5 data bits");
-        }
-        else {
-            Settings.StopBits = stopBits;
+        } else {
+            settings.StopBits = stopBits;
             settingsDirtyFlags |= DFE_StopBits;
         }
         break;
 
         /*two stop bits*/
     case STOP_2:
-        if (Settings.DataBits==DATA_5) {
+        if (settings.DataBits == DATA_5) {
             QESP_WARNING("QextSerialPort: 2 stop bits cannot be used with 5 data bits");
-        }
-        else {
-            Settings.StopBits = stopBits;
+        } else {
+            settings.StopBits = stopBits;
             settingsDirtyFlags |= DFE_StopBits;
         }
         break;
 
 void QextSerialPortPrivate::setFlowControl(FlowType flow, bool update)
 {
-    Settings.FlowControl=flow;
+    settings.FlowControl = flow;
     settingsDirtyFlags |= DFE_Flow;
     if (update && q_func()->isOpen())
         updatePortSettings();
 
 void QextSerialPortPrivate::setTimeout(long millisec, bool update)
 {
-    Settings.Timeout_Millisec = millisec;
+    settings.Timeout_Millisec = millisec;
     settingsDirtyFlags |= DFE_TimeOut;
     if (update && q_func()->isOpen())
         updatePortSettings();
 {
     qint64 maxSize = bytesAvailable_sys();
     if (maxSize > 0) {
-        char * writePtr = readBuffer.reserve(size_t(maxSize));
+        char *writePtr = readBuffer.reserve(size_t(maxSize));
         qint64 bytesRead = readData_sys(writePtr, maxSize);
         if (bytesRead < maxSize)
             readBuffer.chop(maxSize - bytesRead);
 
     \bold Example
     \code
-    QextSerialPort* port = new QextSerialPort("COM1");
+    QextSerialPort *port = new QextSerialPort("COM1");
     connect(port, SIGNAL(readyRead()), myClass, SLOT(onDataAvailable()));
     port->open();
 
     \a name is the name of the device, which is windowsystem-specific,
     e.g."COM1" or "/dev/ttyS0". \a mode
 */
-QextSerialPort::QextSerialPort(const QString & name, QextSerialPort::QueryMode mode, QObject *parent)
+QextSerialPort::QextSerialPort(const QString &name, QextSerialPort::QueryMode mode, QObject *parent)
     : QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
 {
     setQueryMode(mode);
 /*!
     Constructs a port with default name and specified \a settings.
 */
-QextSerialPort::QextSerialPort(const PortSettings& settings, QextSerialPort::QueryMode mode, QObject *parent)
+QextSerialPort::QextSerialPort(const PortSettings &settings, QextSerialPort::QueryMode mode, QObject *parent)
     : QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
 {
     Q_D(QextSerialPort);
 /*!
     Constructs a port with specified \a name , \a mode and \a settings.
 */
-QextSerialPort::QextSerialPort(const QString & name, const PortSettings& settings, QextSerialPort::QueryMode mode, QObject *parent)
+QextSerialPort::QextSerialPort(const QString &name, const PortSettings &settings, QextSerialPort::QueryMode mode, QObject *parent)
     : QIODevice(parent), d_ptr(new QextSerialPortPrivate(this))
 {
     Q_D(QextSerialPort);
     Note that this function does not specify which device to open.
     Returns true if successful; otherwise returns false.This function has no effect
     if the port associated with the class is already open.  The port is also
-    configured to the current settings, as stored in the Settings structure.
+    configured to the current settings, as stored in the settings structure.
 */
 bool QextSerialPort::open(OpenMode mode)
 {
         if (bytes != -1) {
             return bytes + d_func()->readBuffer.size()
                     + QIODevice::bytesAvailable();
-        } else {
-            return -1;
         }
+        return -1;
     }
     return 0;
 }
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (mode != d->_queryMode) {
-        d->_queryMode = mode;
-    }
+    if (mode != d->queryMode)
+        d->queryMode = mode;
 }
 
 /*!
     Sets the \a name of the device associated with the object, e.g. "COM1", or "/dev/ttyS0".
 */
-void QextSerialPort::setPortName(const QString & name)
+void QextSerialPort::setPortName(const QString &name)
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
 QextSerialPort::QueryMode QextSerialPort::queryMode() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->_queryMode;
+    return d_func()->queryMode;
 }
 
 /*!
 BaudRateType QextSerialPort::baudRate() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->Settings.BaudRate;
+    return d_func()->settings.BaudRate;
 }
 
 /*!
 DataBitsType QextSerialPort::dataBits() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->Settings.DataBits;
+    return d_func()->settings.DataBits;
 }
 
 /*!
 ParityType QextSerialPort::parity() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->Settings.Parity;
+    return d_func()->settings.Parity;
 }
 
 /*!
 StopBitsType QextSerialPort::stopBits() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->Settings.StopBits;
+    return d_func()->settings.StopBits;
 }
 
 /*!
 FlowType QextSerialPort::flowControl() const
 {
     QReadLocker locker(&d_func()->lock);
-    return d_func()->Settings.FlowControl;
+    return d_func()->settings.FlowControl;
 }
 
 /*!
 */
 QextSerialPort::~QextSerialPort()
 {
-    if (isOpen()) {
+    if (isOpen())
         close();
-    }
+
     delete d_ptr;
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.FlowControl != flow)
+    if (d->settings.FlowControl != flow)
         d->setFlowControl(flow, true);
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.Parity != parity)
+    if (d->settings.Parity != parity)
         d->setParity(parity, true);
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.DataBits != dataBits)
+    if (d->settings.DataBits != dataBits)
         d->setDataBits(dataBits, true);
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.StopBits != stopBits)
+    if (d->settings.StopBits != stopBits)
         d->setStopBits(stopBits, true);
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.BaudRate != baudRate)
+    if (d->settings.BaudRate != baudRate)
         d->setBaudRate(baudRate, true);
 }
 
 {
     Q_D(QextSerialPort);
     QWriteLocker locker(&d->lock);
-    if (d->Settings.Timeout_Millisec != millisec)
+    if (d->settings.Timeout_Millisec != millisec)
         d->setTimeout(millisec, true);
 }
 
             return bytesFromBuffer;
     }
     qint64 bytesFromDevice = d->readData_sys(data+bytesFromBuffer, maxSize-bytesFromBuffer);
-    if (bytesFromDevice < 0) {
+    if (bytesFromDevice < 0)
         return -1;
-    }
     return bytesFromBuffer + bytesFromDevice;
 }
 

src/3rdparty/qextserialport/src/qextserialport.h

         EventDriven
     };
 
-    explicit QextSerialPort(QueryMode mode = EventDriven, QObject* parent = 0);
-    explicit QextSerialPort(const QString & name, QueryMode mode = EventDriven, QObject * parent = 0);
-    explicit QextSerialPort(const PortSettings & s, QueryMode mode = EventDriven, QObject * parent = 0);
-    QextSerialPort(const QString & name, const PortSettings& s, QueryMode mode = EventDriven, QObject *parent=0);
+    explicit QextSerialPort(QueryMode mode = EventDriven, QObject *parent = 0);
+    explicit QextSerialPort(const QString &name, QueryMode mode = EventDriven, QObject *parent = 0);
+    explicit QextSerialPort(const PortSettings &s, QueryMode mode = EventDriven, QObject *parent = 0);
+    QextSerialPort(const QString &name, const PortSettings &s, QueryMode mode = EventDriven, QObject *parent=0);
 
     ~QextSerialPort();
 
     QString errorString();
 
 public Q_SLOTS:
-    void setPortName(const QString & name);
+    void setPortName(const QString &name);
     void setQueryMode(QueryMode mode);
     void setBaudRate(BaudRateType);
     void setDataBits(DataBitsType);
     void dsrChanged(bool status);
 
 protected:
-    qint64 readData(char * data, qint64 maxSize);
-    qint64 writeData(const char * data, qint64 maxSize);
+    qint64 readData(char *data, qint64 maxSize);
+    qint64 writeData(const char *data, qint64 maxSize);
 
 private:
     Q_DISABLE_COPY(QextSerialPort)

src/3rdparty/qextserialport/src/qextserialport.pri

-exists(../common.pri) {
-    #For case:
-    #  someone want to copy all file in the src/ directory
-    #  to their project src/ directory and they does not like
-    #  the common.pri file.
-    #In this case:
-    #  they can just include this file (qextserialport.pri) too.
-    include(../common.pri)
-}
 INCLUDEPATH += $$PWD
 DEPENDPATH += $$PWD
 
-qextserialport-library:!qextserialport-buildlib {
-    # Using QextSerialPort as shared or static library.
-    LIBS += -L$$QEXTSERIALPORT_LIBDIR -l$$QEXTSERIALPORT_LIBNAME
-   !qextserialport-static: DEFINES += QEXTSERIALPORT_USING_SHARED
-} else {
-    # Building library(shared or static)
-    # or including source files
-    HEADERS                += $$PWD/qextserialport.h \
-                              $$PWD/qextserialport_p.h \
-                              $$PWD/qextserialenumerator.h \
-                              $$PWD/qextserialenumerator_p.h \
-                              $$PWD/qextserialport_global.h
-    SOURCES                += $$PWD/qextserialport.cpp \
-                              $$PWD/qextserialenumerator.cpp
-    unix:SOURCES           += $$PWD/qextserialport_unix.cpp
-    unix:!macx:SOURCES     += $$PWD/qextserialenumerator_unix.cpp
-    macx:SOURCES           += $$PWD/qextserialenumerator_osx.cpp
-    win32:SOURCES          += $$PWD/qextserialport_win.cpp \
-                              $$PWD/qextserialenumerator_win.cpp
+PUBLIC_HEADERS         += $$PWD/qextserialport.h \
+                          $$PWD/qextserialenumerator.h \
+                          $$PWD/qextserialport_global.h
 
-    # For Windows user who doesn't have Qt4's Private files
-    win32:contains(QT_VERSION, ^4\\..*\\..*):!exists($$[QT_INSTALL_HEADERS]/QtCore/private/qwineventnotifier_p.h){
-        DEFINES            += QESP_NO_QT4_PRIVATE
-        HEADERS            += $$PWD/qextwineventnotifier_p.h
-        SOURCES            += $$PWD/qextwineventnotifier_p.cpp
-    }
+HEADERS                += $$PUBLIC_HEADERS \
+                          $$PWD/qextserialport_p.h \
+                          $$PWD/qextserialenumerator_p.h \
 
-    # For building shared library only
-    qextserialport-buildlib:contains(TEMPLATE, .*lib):contains(CONFIG, shared){
-        DEFINES += QEXTSERIALPORT_BUILD_SHARED
+SOURCES                += $$PWD/qextserialport.cpp \
+                          $$PWD/qextserialenumerator.cpp
+unix {
+    SOURCES            += $$PWD/qextserialport_unix.cpp
+    linux* {
+        SOURCES        += $$PWD/qextserialenumerator_linux.cpp
+    } else:macx {
+        SOURCES        += $$PWD/qextserialenumerator_osx.cpp
+    } else {
+        SOURCES        += $$PWD/qextserialenumerator_unix.cpp
     }
 }
+win32:SOURCES          += $$PWD/qextserialport_win.cpp \
+                          $$PWD/qextserialenumerator_win.cpp
+
+linux*{
+    !qesp_linux_udev:DEFINES += QESP_NO_UDEV
+    qesp_linux_udev: LIBS += -ludev
+}
 
 macx:LIBS              += -framework IOKit -framework CoreFoundation
 win32:LIBS             += -lsetupapi -ladvapi32 -luser32
+
+# moc doesn't detect Q_OS_LINUX correctly, so add this to make it work
+linux*:DEFINES += __linux__

src/3rdparty/qextserialport/src/qextserialport_global.h

 
 /*macros for warning and debug messages*/
 #ifdef QESP_NO_PORTABILITY_WARN
-#  define QESP_PORTABILITY_WARNING  while(false)qWarning
+#  define QESP_PORTABILITY_WARNING  while (false)qWarning
 #else
 #  define QESP_PORTABILITY_WARNING qWarning
 #endif /*QESP_NOWARN_PORT*/
 
 #ifdef QESP_NO_WARN
-#  define QESP_WARNING while(false)qWarning
+#  define QESP_WARNING while (false)qWarning
 #else
 #  define QESP_WARNING qWarning
 #endif /*QESP_NOWARN*/

src/3rdparty/qextserialport/src/qextserialport_p.h

         return len == 0;
     }
 
-    inline int read(char* target, int size) {
+    inline int read(char *target, int size) {
         int r = qMin(size, len);
         if (r == 1) {
             *target = *first;
         return r;
     }
 
-    inline char* reserve(size_t size) {
+    inline char *reserve(size_t size) {
         if ((first - buf) + len + size > capacity) {
             size_t newCapacity = qMax(capacity, basicBlockSize);
-            while (newCapacity < size)
+            while (newCapacity < len + size)
                 newCapacity *= 2;
             if (newCapacity > capacity) {
                 // allocate more space
-                char* newBuf = new char[newCapacity];
+                char *newBuf = new char[newCapacity];
                 memmove(newBuf, first, len);
                 delete [] buf;
                 buf = newBuf;
             }
             first = buf;
         }
-        char* writePtr = first + len;
+        char *writePtr = first + len;
         len += (int)size;
         return writePtr;
     }
 
     inline void chop(int size) {
-        if (size >= len) {
+        if (size >= len)
             clear();
-        } else {
+        else
             len -= size;
-        }
     }
 
     inline void squeeze() {
         while (newCapacity < size_t(len))
             newCapacity *= 2;
         if (newCapacity < capacity) {
-            char * tmp = static_cast<char*>(realloc(buf, newCapacity));
+            char *tmp = static_cast<char *>(realloc(buf, newCapacity));
             if (tmp) {
                 buf = tmp;
                 capacity = newCapacity;
     }
 
     inline QByteArray readAll() {
-        char* f = first;
+        char *f = first;
         int l = len;
         clear();
         return QByteArray(f, l);
     }
 
-    inline int readLine(char* target, int size) {
+    inline int readLine(char *target, int size) {
         int r = qMin(size, len);
-        char* eol = static_cast<char*>(memchr(first, '\n', r));
+        char *eol = static_cast<char *>(memchr(first, '\n', r));
         if (eol)
             r = 1+(eol-first);
         memcpy(target, first, r);
 
 private:
     int len;
-    char* first;
-    char* buf;
+    char *first;
+    char *buf;
     size_t capacity;
     size_t basicBlockSize;
 };
 
-class QextWinEventNotifier;
 class QWinEventNotifier;
 class QReadWriteLock;
 class QSocketNotifier;
 {
     Q_DECLARE_PUBLIC(QextSerialPort)
 public:
-    QextSerialPortPrivate(QextSerialPort * q);
+    QextSerialPortPrivate(QextSerialPort *q);
     ~QextSerialPortPrivate();
     enum DirtyFlagEnum
     {
     };
     mutable QReadWriteLock lock;
     QString port;
-    PortSettings Settings;
+    PortSettings settings;
     QextReadBuffer readBuffer;
     int settingsDirtyFlags;
     ulong lastErr;
-    QextSerialPort::QueryMode _queryMode;
+    QextSerialPort::QueryMode queryMode;
 
     // platform specific members
 #ifdef Q_OS_UNIX
     int fd;
     QSocketNotifier *readNotifier;
-    struct termios Posix_CommConfig;
-    struct termios old_termios;
+    struct termios currentTermios;
+    struct termios oldTermios;
 #elif (defined Q_OS_WIN)
-    HANDLE Win_Handle;
+    HANDLE handle;
     OVERLAPPED overlap;
-    COMMCONFIG Win_CommConfig;
-    COMMTIMEOUTS Win_CommTimeouts;
-#  ifndef QESP_NO_QT4_PRIVATE
+    COMMCONFIG commConfig;
+    COMMTIMEOUTS commTimeouts;
     QWinEventNotifier *winEventNotifier;
-#  else
-    QextWinEventNotifier *winEventNotifier;
-#  endif
     DWORD eventMask;
-    QList<OVERLAPPED*> pendingWrites;
-    QReadWriteLock* bytesToWriteLock;
-    qint64 _bytesToWrite;
+    QList<OVERLAPPED *> pendingWrites;
+    QReadWriteLock *bytesToWriteLock;
 #endif
 
     /*fill PortSettings*/
     void setStopBits(StopBitsType stopbits, bool update=true);
     void setFlowControl(FlowType flow, bool update=true);
     void setTimeout(long millisec, bool update=true);
-    void setPortSettings(const PortSettings& settings, bool update=true);
+    void setPortSettings(const PortSettings &settings, bool update=true);
 
     void platformSpecificDestruct();
     void platformSpecificInit();
     void translateError(ulong error);
     void updatePortSettings();
 
-    qint64 readData_sys(char * data, qint64 maxSize);
-    qint64 writeData_sys(const char * data, qint64 maxSize);
+    qint64 readData_sys(char *data, qint64 maxSize);
+    qint64 writeData_sys(const char *data, qint64 maxSize);
     void setDtr_sys(bool set=true);
     void setRts_sys(bool set=true);
     bool open_sys(QIODevice::OpenMode mode);
 #endif
     void _q_canRead();
 
-    QextSerialPort * q_ptr;
+    QextSerialPort *q_ptr;
 };
 
 #endif //_QEXTSERIALPORT_P_H_

src/3rdparty/qextserialport/src/qextserialport_unix.cpp

 {
 }
 
+static QString fullPortName(const QString &name)
+{
+    if (name.startsWith(QLatin1Char('/')))
+        return name;
+    return QLatin1String("/dev/")+name;
+}
+
 bool QextSerialPortPrivate::open_sys(QIODevice::OpenMode mode)
 {
     Q_Q(QextSerialPort);
     //note: linux 2.6.21 seems to ignore O_NDELAY flag
-    if ((fd = ::open(port.toAscii() ,O_RDWR | O_NOCTTY | O_NDELAY)) != -1) {
+    if ((fd = ::open(fullPortName(port).toLatin1() ,O_RDWR | O_NOCTTY | O_NDELAY)) != -1) {
 
         /*In the Private class, We can not call QIODevice::open()*/
         q->setOpenMode(mode);             // Flag the port as opened
-        ::tcgetattr(fd, &old_termios);    // Save the old termios
-        Posix_CommConfig = old_termios;   // Make a working copy
-        ::cfmakeraw(&Posix_CommConfig);   // Enable raw access
+        ::tcgetattr(fd, &oldTermios);    // Save the old termios
+        currentTermios = oldTermios;   // Make a working copy
+        ::cfmakeraw(&currentTermios);   // Enable raw access
 
         /*set up other port settings*/
-        Posix_CommConfig.c_cflag |= CREAD|CLOCAL;
-        Posix_CommConfig.c_lflag &= (~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG));
-        Posix_CommConfig.c_iflag &= (~(INPCK|IGNPAR|PARMRK|ISTRIP|ICRNL|IXANY));
-        Posix_CommConfig.c_oflag &= (~OPOST);
-        Posix_CommConfig.c_cc[VMIN] = 0;
+        currentTermios.c_cflag |= CREAD|CLOCAL;
+        currentTermios.c_lflag &= (~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|ISIG));
+        currentTermios.c_iflag &= (~(INPCK|IGNPAR|PARMRK|ISTRIP|ICRNL|IXANY));
+        currentTermios.c_oflag &= (~OPOST);
+        currentTermios.c_cc[VMIN] = 0;
 #ifdef _POSIX_VDISABLE  // Is a disable character available on this system?
         // Some systems allow for per-device disable-characters, so get the
         //  proper value for the configured device
         const long vdisable = ::fpathconf(fd, _PC_VDISABLE);
-        Posix_CommConfig.c_cc[VINTR] = vdisable;
-        Posix_CommConfig.c_cc[VQUIT] = vdisable;
-        Posix_CommConfig.c_cc[VSTART] = vdisable;
-        Posix_CommConfig.c_cc[VSTOP] = vdisable;
-        Posix_CommConfig.c_cc[VSUSP] = vdisable;
+        currentTermios.c_cc[VINTR] = vdisable;
+        currentTermios.c_cc[VQUIT] = vdisable;
+        currentTermios.c_cc[VSTART] = vdisable;
+        currentTermios.c_cc[VSTOP] = vdisable;
+        currentTermios.c_cc[VSUSP] = vdisable;
 #endif //_POSIX_VDISABLE
         settingsDirtyFlags = DFE_ALL;
         updatePortSettings();
 
-        if (_queryMode == QextSerialPort::EventDriven) {
+        if (queryMode == QextSerialPort::EventDriven) {
             readNotifier = new QSocketNotifier(fd, QSocketNotifier::Read, q);
             q->connect(readNotifier, SIGNAL(activated(int)), q, SLOT(_q_canRead()));
         }
     // Force a flush and then restore the original termios
     flush_sys();
     // Using both TCSAFLUSH and TCSANOW here discards any pending input
-    ::tcsetattr(fd, TCSAFLUSH | TCSANOW, &old_termios);   // Restore termios
+    ::tcsetattr(fd, TCSAFLUSH | TCSANOW, &oldTermios);   // Restore termios
     ::close(fd);
-    if(readNotifier) {
+    if (readNotifier) {
         delete readNotifier;
         readNotifier = 0;
     }
 qint64 QextSerialPortPrivate::bytesAvailable_sys() const
 {
     int bytesQueued;
-    if (::ioctl(fd, FIONREAD, &bytesQueued) == -1) {
+    if (::ioctl(fd, FIONREAD, &bytesQueued) == -1)
         return (qint64)-1;
-    }
     return bytesQueued;
 }
 
     ::ioctl(fd, TIOCMGET, &Temp);
     if (Temp & TIOCM_CTS) Status |= LS_CTS;
     if (Temp & TIOCM_DSR) Status |= LS_DSR;
-    if (Temp & TIOCM_RI ) Status |= LS_RI;
-    if (Temp & TIOCM_CD ) Status |= LS_DCD;
+    if (Temp & TIOCM_RI) Status |= LS_RI;
+    if (Temp & TIOCM_CD) Status |= LS_DCD;
     if (Temp & TIOCM_DTR) Status |= LS_DTR;
     if (Temp & TIOCM_RTS) Status |= LS_RTS;
-    if (Temp & TIOCM_ST ) Status |= LS_ST;
-    if (Temp & TIOCM_SR ) Status |= LS_SR;
+    if (Temp & TIOCM_ST) Status |= LS_ST;
+    if (Temp & TIOCM_SR) Status |= LS_SR;
     return Status;
 }
 
     \warning before calling this function ensure that serial port associated with this class
     is currently open (use isOpen() function to check if port is open).
 */
-qint64 QextSerialPortPrivate::readData_sys(char * data, qint64 maxSize)
+qint64 QextSerialPortPrivate::readData_sys(char *data, qint64 maxSize)
 {
     int retVal = ::read(fd, data, maxSize);
     if (retVal == -1)
     \warning before calling this function ensure that serial port associated with this class
     is currently open (use isOpen() function to check if port is open).
 */
-qint64 QextSerialPortPrivate::writeData_sys(const char * data, qint64 maxSize)
+qint64 QextSerialPortPrivate::writeData_sys(const char *data, qint64 maxSize)
 {
     int retVal = ::write(fd, data, maxSize);
     if (retVal == -1)
         return;
 
     if (settingsDirtyFlags & DFE_BaudRate) {
-        switch (Settings.BaudRate) {
+        switch (settings.BaudRate) {
         case BAUD50:
-            setBaudRate2Termios(&Posix_CommConfig, B50);
+            setBaudRate2Termios(&currentTermios, B50);
             break;
         case BAUD75:
-            setBaudRate2Termios(&Posix_CommConfig, B75);
+            setBaudRate2Termios(&currentTermios, B75);
             break;
         case BAUD110:
-            setBaudRate2Termios(&Posix_CommConfig, B110);
+            setBaudRate2Termios(&currentTermios, B110);
             break;
         case BAUD134:
-            setBaudRate2Termios(&Posix_CommConfig, B134);
+            setBaudRate2Termios(&currentTermios, B134);
             break;
         case BAUD150:
-            setBaudRate2Termios(&Posix_CommConfig, B150);
+            setBaudRate2Termios(&currentTermios, B150);
             break;
         case BAUD200:
-            setBaudRate2Termios(&Posix_CommConfig, B200);
+            setBaudRate2Termios(&currentTermios, B200);
             break;
         case BAUD300:
-            setBaudRate2Termios(&Posix_CommConfig, B300);
+            setBaudRate2Termios(&currentTermios, B300);
             break;
         case BAUD600:
-            setBaudRate2Termios(&Posix_CommConfig, B600);
+            setBaudRate2Termios(&currentTermios, B600);
             break;
         case BAUD1200:
-            setBaudRate2Termios(&Posix_CommConfig, B1200);
+            setBaudRate2Termios(&currentTermios, B1200);
             break;
         case BAUD1800:
-            setBaudRate2Termios(&Posix_CommConfig, B1800);
+            setBaudRate2Termios(&currentTermios, B1800);
             break;
         case BAUD2400:
-            setBaudRate2Termios(&Posix_CommConfig, B2400);
+            setBaudRate2Termios(&currentTermios, B2400);
             break;
         case BAUD4800:
-            setBaudRate2Termios(&Posix_CommConfig, B4800);
+            setBaudRate2Termios(&currentTermios, B4800);
             break;
         case BAUD9600:
-            setBaudRate2Termios(&Posix_CommConfig, B9600);
+            setBaudRate2Termios(&currentTermios, B9600);
             break;
         case BAUD19200:
-            setBaudRate2Termios(&Posix_CommConfig, B19200);
+            setBaudRate2Termios(&currentTermios, B19200);
             break;
         case BAUD38400:
-            setBaudRate2Termios(&Posix_CommConfig, B38400);
+            setBaudRate2Termios(&currentTermios, B38400);
             break;
         case BAUD57600:
-            setBaudRate2Termios(&Posix_CommConfig, B57600);
+            setBaudRate2Termios(&currentTermios, B57600);
             break;
 #ifdef B76800
         case BAUD76800:
-            setBaudRate2Termios(&Posix_CommConfig, B76800);
+            setBaudRate2Termios(&currentTermios, B76800);
             break;
 #endif
         case BAUD115200:
-            setBaudRate2Termios(&Posix_CommConfig, B115200);
+            setBaudRate2Termios(&currentTermios, B115200);
             break;
 #if defined(B230400) && defined(B4000000)
         case BAUD230400:
-            setBaudRate2Termios(&Posix_CommConfig, B230400);
+            setBaudRate2Termios(&currentTermios, B230400);
             break;
         case BAUD460800:
-            setBaudRate2Termios(&Posix_CommConfig, B460800);
+            setBaudRate2Termios(&currentTermios, B460800);
             break;
         case BAUD500000:
-            setBaudRate2Termios(&Posix_CommConfig, B500000);
+            setBaudRate2Termios(&currentTermios, B500000);
             break;
         case BAUD576000:
-            setBaudRate2Termios(&Posix_CommConfig, B576000);
+            setBaudRate2Termios(&currentTermios, B576000);
             break;
         case BAUD921600:
-            setBaudRate2Termios(&Posix_CommConfig, B921600);
+            setBaudRate2Termios(&currentTermios, B921600);
             break;
         case BAUD1000000:
-            setBaudRate2Termios(&Posix_CommConfig, B1000000);
+            setBaudRate2Termios(&currentTermios, B1000000);
             break;
         case BAUD1152000:
-            setBaudRate2Termios(&Posix_CommConfig, B1152000);
+            setBaudRate2Termios(&currentTermios, B1152000);
             break;
         case BAUD1500000:
-            setBaudRate2Termios(&Posix_CommConfig, B1500000);
+            setBaudRate2Termios(&currentTermios, B1500000);
             break;
         case BAUD2000000:
-            setBaudRate2Termios(&Posix_CommConfig, B2000000);
+            setBaudRate2Termios(&currentTermios, B2000000);
             break;
         case BAUD2500000:
-            setBaudRate2Termios(&Posix_CommConfig, B2500000);
+            setBaudRate2Termios(&currentTermios, B2500000);
             break;
         case BAUD3000000:
-            setBaudRate2Termios(&Posix_CommConfig, B3000000);
+            setBaudRate2Termios(&currentTermios, B3000000);
             break;
         case BAUD3500000:
-            setBaudRate2Termios(&Posix_CommConfig, B3500000);
+            setBaudRate2Termios(&currentTermios, B3500000);
             break;
         case BAUD4000000:
-            setBaudRate2Termios(&Posix_CommConfig, B4000000);
+            setBaudRate2Termios(&currentTermios, B4000000);
+            break;
+#endif
+#ifdef Q_OS_MAC
+        default:
+            setBaudRate2Termios(&currentTermios, settings.BaudRate);
             break;
 #endif
         }
     }
     if (settingsDirtyFlags & DFE_Parity) {
-        switch (Settings.Parity) {
+        switch (settings.Parity) {
         case PAR_SPACE:
             /*space parity not directly supported - add an extra data bit to simulate it*/
             settingsDirtyFlags |= DFE_DataBits;
             break;
         case PAR_NONE:
-            Posix_CommConfig.c_cflag &= (~PARENB);
+            currentTermios.c_cflag &= (~PARENB);
             break;
         case PAR_EVEN:
-            Posix_CommConfig.c_cflag &= (~PARODD);
-            Posix_CommConfig.c_cflag |= PARENB;
+            currentTermios.c_cflag &= (~PARODD);
+            currentTermios.c_cflag |= PARENB;
             break;
         case PAR_ODD:
-            Posix_CommConfig.c_cflag |= (PARENB|PARODD);
+            currentTermios.c_cflag |= (PARENB|PARODD);
             break;
         }
     }
     /*must after Parity settings*/
     if (settingsDirtyFlags & DFE_DataBits) {
-        if (Settings.Parity != PAR_SPACE) {
-            Posix_CommConfig.c_cflag &= (~CSIZE);
-            switch(Settings.DataBits) {
+        if (settings.Parity != PAR_SPACE) {
+            currentTermios.c_cflag &= (~CSIZE);
+            switch(settings.DataBits) {
             case DATA_5:
-                Posix_CommConfig.c_cflag |= CS5;
+                currentTermios.c_cflag |= CS5;
                 break;
             case DATA_6:
-                Posix_CommConfig.c_cflag |= CS6;
+                currentTermios.c_cflag |= CS6;
                 break;
             case DATA_7:
-                Posix_CommConfig.c_cflag |= CS7;
+                currentTermios.c_cflag |= CS7;
                 break;
             case DATA_8:
-                Posix_CommConfig.c_cflag |= CS8;
+                currentTermios.c_cflag |= CS8;
                 break;
             }
         } else {
             /*space parity not directly supported - add an extra data bit to simulate it*/
-            Posix_CommConfig.c_cflag &= ~(PARENB|CSIZE);
-            switch(Settings.DataBits) {
+            currentTermios.c_cflag &= ~(PARENB|CSIZE);
+            switch(settings.DataBits) {
             case DATA_5:
-                Posix_CommConfig.c_cflag |= CS6;
+                currentTermios.c_cflag |= CS6;
                 break;
             case DATA_6:
-                Posix_CommConfig.c_cflag |= CS7;
+                currentTermios.c_cflag |= CS7;
                 break;
             case DATA_7:
-                Posix_CommConfig.c_cflag |= CS8;
+                currentTermios.c_cflag |= CS8;
                 break;
             case DATA_8:
                 /*this will never happen, put here to Suppress an warning*/
         }
     }
     if (settingsDirtyFlags & DFE_StopBits) {
-        switch (Settings.StopBits) {
+        switch (settings.StopBits) {
         case STOP_1:
-            Posix_CommConfig.c_cflag &= (~CSTOPB);
+            currentTermios.c_cflag &= (~CSTOPB);
             break;
         case STOP_2:
-            Posix_CommConfig.c_cflag |= CSTOPB;
+            currentTermios.c_cflag |= CSTOPB;
             break;
         }
     }
     if (settingsDirtyFlags & DFE_Flow) {
-        switch(Settings.FlowControl) {
+        switch(settings.FlowControl) {
         case FLOW_OFF:
-            Posix_CommConfig.c_cflag &= (~CRTSCTS);
-            Posix_CommConfig.c_iflag &= (~(IXON|IXOFF|IXANY));
+            currentTermios.c_cflag &= (~CRTSCTS);
+            currentTermios.c_iflag &= (~(IXON|IXOFF|IXANY));
             break;
         case FLOW_XONXOFF:
             /*software (XON/XOFF) flow control*/
-            Posix_CommConfig.c_cflag &= (~CRTSCTS);
-            Posix_CommConfig.c_iflag |= (IXON|IXOFF|IXANY);
+            currentTermios.c_cflag &= (~CRTSCTS);
+            currentTermios.c_iflag |= (IXON|IXOFF|IXANY);
             break;
         case FLOW_HARDWARE:
-            Posix_CommConfig.c_cflag |= CRTSCTS;
-            Posix_CommConfig.c_iflag &= (~(IXON|IXOFF|IXANY));
+            currentTermios.c_cflag |= CRTSCTS;
+            currentTermios.c_iflag &= (~(IXON|IXOFF|IXANY));
             break;
         }
     }
 
-    /*if any thing in Posix_CommConfig changed, flush*/
+    /*if any thing in currentTermios changed, flush*/
     if (settingsDirtyFlags & DFE_Settings_Mask)
-        ::tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig);
+        ::tcsetattr(fd, TCSAFLUSH, &currentTermios);
 
     if (settingsDirtyFlags & DFE_TimeOut) {
-        int millisec = Settings.Timeout_Millisec;
+        int millisec = settings.Timeout_Millisec;
         if (millisec == -1) {
             ::fcntl(fd, F_SETFL, O_NDELAY);
-        }
-        else {
+        } else {
             //O_SYNC should enable blocking ::write()
             //however this seems not working on Linux 2.6.21 (works on OpenBSD 4.2)
             ::fcntl(fd, F_SETFL, O_SYNC);
         }
-        ::tcgetattr(fd, & Posix_CommConfig);
-        Posix_CommConfig.c_cc[VTIME] = millisec/100;
-        ::tcsetattr(fd, TCSAFLUSH, & Posix_CommConfig);
+        ::tcgetattr(fd, &currentTermios);
+        currentTermios.c_cc[VTIME] = millisec/100;
+        ::tcsetattr(fd, TCSAFLUSH, &currentTermios);
     }
 
     settingsDirtyFlags = 0;

src/3rdparty/qextserialport/src/qextserialport_win.cpp

 #include <QtCore/QMetaType>
 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
 #  include <QtCore/QWinEventNotifier>
-#  define WinEventNotifier QWinEventNotifier
-#elif !defined(QESP_NO_QT4_PRIVATE)
-#  include <QtCore/private/qwineventnotifier_p.h>
-#  define WinEventNotifier QWinEventNotifier
 #else
-#  include "qextwineventnotifier_p.h"
-#  define WinEventNotifier QextWinEventNotifier
+#  include <QtCore/private/qwineventnotifier_p.h>
 #endif
 void QextSerialPortPrivate::platformSpecificInit()
 {
-    Win_Handle=INVALID_HANDLE_VALUE;
+    handle = INVALID_HANDLE_VALUE;
     ZeroMemory(&overlap, sizeof(OVERLAPPED));
     overlap.hEvent = CreateEvent(NULL, true, false, NULL);
     winEventNotifier = 0;
     bytesToWriteLock = new QReadWriteLock;
-    _bytesToWrite = 0;
 }
 
 void QextSerialPortPrivate::platformSpecificDestruct() {
 
     This is only need when open the port.
 */
-static QString fullPortNameWin(const QString & name)
+static QString fullPortNameWin(const QString &name)
 {
     QRegExp rx(QLatin1String("^COM(\\d+)"));
     QString fullName(name);
-    if(fullName.contains(rx))
+    if (fullName.contains(rx))
         fullName.prepend(QLatin1String("\\\\.\\"));
     return fullName;
 }
 {
     Q_Q(QextSerialPort);
     DWORD confSize = sizeof(COMMCONFIG);
-    Win_CommConfig.dwSize = confSize;
+    commConfig.dwSize = confSize;
     DWORD dwFlagsAndAttributes = 0;
-    if (_queryMode == QextSerialPort::EventDriven)
+    if (queryMode == QextSerialPort::EventDriven)
         dwFlagsAndAttributes += FILE_FLAG_OVERLAPPED;
 
     /*open the port*/
-    Win_Handle=CreateFileW((wchar_t*)fullPortNameWin(port).utf16(), GENERIC_READ|GENERIC_WRITE,
+    handle = CreateFileW((wchar_t *)fullPortNameWin(port).utf16(), GENERIC_READ|GENERIC_WRITE,
                            0, NULL, OPEN_EXISTING, dwFlagsAndAttributes, NULL);
-    if (Win_Handle!=INVALID_HANDLE_VALUE) {
+    if (handle != INVALID_HANDLE_VALUE) {
         q->setOpenMode(mode);
         /*configure port settings*/
-        GetCommConfig(Win_Handle, &Win_CommConfig, &confSize);
-        GetCommState(Win_Handle, &(Win_CommConfig.dcb));
+        GetCommConfig(handle, &commConfig, &confSize);
+        GetCommState(handle, &(commConfig.dcb));
 
         /*set up parameters*/
-        Win_CommConfig.dcb.fBinary=TRUE;
-        Win_CommConfig.dcb.fInX=FALSE;
-        Win_CommConfig.dcb.fOutX=FALSE;
-        Win_CommConfig.dcb.fAbortOnError=FALSE;
-        Win_CommConfig.dcb.fNull=FALSE;
+        commConfig.dcb.fBinary = TRUE;
+        commConfig.dcb.fInX = FALSE;
+        commConfig.dcb.fOutX = FALSE;
+        commConfig.dcb.fAbortOnError = FALSE;
+        commConfig.dcb.fNull = FALSE;
         /* Dtr default to true. See Issue 122*/
-        Win_CommConfig.dcb.fDtrControl=TRUE;
+        commConfig.dcb.fDtrControl = TRUE;
         /*flush all settings*/
         settingsDirtyFlags = DFE_ALL;
         updatePortSettings();
 
         //init event driven approach
-        if (_queryMode == QextSerialPort::EventDriven) {
-            if (!SetCommMask( Win_Handle, EV_TXEMPTY | EV_RXCHAR | EV_DSR)) {
+        if (queryMode == QextSerialPort::EventDriven) {
+            if (!SetCommMask(handle, EV_TXEMPTY | EV_RXCHAR | EV_DSR)) {
                 QESP_WARNING()<<"failed to set Comm Mask. Error code:"<<GetLastError();
                 return false;
             }
-            winEventNotifier = new WinEventNotifier(overlap.hEvent, q);
+            winEventNotifier = new QWinEventNotifier(overlap.hEvent, q);
             qRegisterMetaType<HANDLE>("HANDLE");
             q->connect(winEventNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_onWinEvent(HANDLE)), Qt::DirectConnection);
-            WaitCommEvent(Win_Handle, &eventMask, &overlap);
+            WaitCommEvent(handle, &eventMask, &overlap);
         }
         return true;
     }
 bool QextSerialPortPrivate::close_sys()
 {
     flush_sys();
-    CancelIo(Win_Handle);
-    if (CloseHandle(Win_Handle))
-        Win_Handle = INVALID_HANDLE_VALUE;
-    if (winEventNotifier){
+    CancelIo(handle);
+    if (CloseHandle(handle))
+        handle = INVALID_HANDLE_VALUE;
+    if (winEventNotifier) {
         winEventNotifier->setEnabled(false);
         winEventNotifier->deleteLater();
         winEventNotifier = 0;
     }
-    _bytesToWrite = 0;
 
-    foreach(OVERLAPPED* o, pendingWrites) {
+    foreach (OVERLAPPED *o, pendingWrites) {
         CloseHandle(o->hEvent);
         delete o;
     }
 
 bool QextSerialPortPrivate::flush_sys()
 {
-    FlushFileBuffers(Win_Handle);
+    FlushFileBuffers(handle);
     return true;
 }
 
 {
     DWORD Errors;
     COMSTAT Status;
-    if (ClearCommError(Win_Handle, &Errors, &Status)) {
+    if (ClearCommError(handle, &Errors, &Status))
         return Status.cbInQue;
-    }
+
     return (qint64)-1;
 }
 
 */
 void QextSerialPortPrivate::translateError(ulong error)
 {
-    if (error&CE_BREAK) {
-        lastErr=E_BREAK_CONDITION;
-    }
-    else if (error&CE_FRAME) {
-        lastErr=E_FRAMING_ERROR;
-    }
-    else if (error&CE_IOE) {
-        lastErr=E_IO_ERROR;
-    }
-    else if (error&CE_MODE) {
-        lastErr=E_INVALID_FD;
-    }
-    else if (error&CE_OVERRUN) {
-        lastErr=E_BUFFER_OVERRUN;
-    }
-    else if (error&CE_RXPARITY) {
-        lastErr=E_RECEIVE_PARITY_ERROR;
-    }
-    else if (error&CE_RXOVER) {
-        lastErr=E_RECEIVE_OVERFLOW;
-    }
-    else if (error&CE_TXFULL) {
-        lastErr=E_TRANSMIT_OVERFLOW;
+    if (error & CE_BREAK) {
+        lastErr = E_BREAK_CONDITION;
+    } else if (error & CE_FRAME) {
+        lastErr = E_FRAMING_ERROR;
+    } else if (error & CE_IOE) {
+        lastErr = E_IO_ERROR;
+    } else if (error & CE_MODE) {
+        lastErr = E_INVALID_FD;
+    } else if (error & CE_OVERRUN) {
+        lastErr = E_BUFFER_OVERRUN;
+    } else if (error & CE_RXPARITY) {
+        lastErr = E_RECEIVE_PARITY_ERROR;
+    } else if (error & CE_RXOVER) {
+        lastErr = E_RECEIVE_OVERFLOW;
+    } else if (error & CE_TXFULL) {
+        lastErr = E_TRANSMIT_OVERFLOW;
     }
 }
 
 {
     DWORD bytesRead = 0;
     bool failed = false;
-    if (_queryMode == QextSerialPort::EventDriven) {
+    if (queryMode == QextSerialPort::EventDriven) {
         OVERLAPPED overlapRead;
         ZeroMemory(&overlapRead, sizeof(OVERLAPPED));
-        if (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesRead, & overlapRead)) {
+        if (!ReadFile(handle, (void *)data, (DWORD)maxSize, &bytesRead, &overlapRead)) {
             if (GetLastError() == ERROR_IO_PENDING)
-                GetOverlappedResult(Win_Handle, & overlapRead, & bytesRead, true);
+                GetOverlappedResult(handle, &overlapRead, &bytesRead, true);
             else
                 failed = true;
         }
-    } else if (!ReadFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesRead, NULL)) {
+    } else if (!ReadFile(handle, (void *)data, (DWORD)maxSize, &bytesRead, NULL)) {
         failed = true;
     }
     if (!failed)
 {
     DWORD bytesWritten = 0;
     bool failed = false;
-    if (_queryMode == QextSerialPort::EventDriven) {
-        OVERLAPPED* newOverlapWrite = new OVERLAPPED;
+    if (queryMode == QextSerialPort::EventDriven) {
+        OVERLAPPED *newOverlapWrite = new OVERLAPPED;
         ZeroMemory(newOverlapWrite, sizeof(OVERLAPPED));
         newOverlapWrite->hEvent = CreateEvent(NULL, true, false, NULL);
-        if (WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesWritten, newOverlapWrite)) {
+        if (WriteFile(handle, (void *)data, (DWORD)maxSize, &bytesWritten, newOverlapWrite)) {
             CloseHandle(newOverlapWrite->hEvent);
             delete newOverlapWrite;
-        }
-        else if (GetLastError() == ERROR_IO_PENDING) {
+        } else if (GetLastError() == ERROR_IO_PENDING) {
             // writing asynchronously...not an error
             QWriteLocker writelocker(bytesToWriteLock);
-            _bytesToWrite += maxSize;
             pendingWrites.append(newOverlapWrite);
-        }
-        else {
+        } else {
             QESP_WARNING()<<"QextSerialPort write error:"<<GetLastError();
             failed = true;
-            if(!CancelIo(newOverlapWrite->hEvent))
+            if (!CancelIo(newOverlapWrite->hEvent))
                 QESP_WARNING("QextSerialPort: couldn't cancel IO");
-            if(!CloseHandle(newOverlapWrite->hEvent))
+            if (!CloseHandle(newOverlapWrite->hEvent))
                 QESP_WARNING("QextSerialPort: couldn't close OVERLAPPED handle");
             delete newOverlapWrite;
         }
-    } else if (!WriteFile(Win_Handle, (void*)data, (DWORD)maxSize, & bytesWritten, NULL)) {
+    } else if (!WriteFile(handle, (void *)data, (DWORD)maxSize, &bytesWritten, NULL)) {
         failed = true;
     }
 
 }
 
 void QextSerialPortPrivate::setDtr_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETDTR : CLRDTR);
+    EscapeCommFunction(handle, set ? SETDTR : CLRDTR);
 }
 
 void QextSerialPortPrivate::setRts_sys(bool set) {
-    EscapeCommFunction(Win_Handle, set ? SETRTS : CLRRTS);
+    EscapeCommFunction(handle, set ? SETRTS : CLRRTS);
 }
 
 ulong QextSerialPortPrivate::lineStatus_sys(void) {
-    unsigned long Status=0, Temp=0;
-    GetCommModemStatus(Win_Handle, &Temp);
-    if (Temp & MS_CTS_ON) Status|=LS_CTS;
-    if (Temp & MS_DSR_ON) Status|=LS_DSR;
-    if (Temp & MS_RING_ON) Status|=LS_RI;
-    if (Temp & MS_RLSD_ON) Status|=LS_DCD;
+    unsigned long Status = 0, Temp = 0;
+    GetCommModemStatus(handle, &Temp);
+    if (Temp & MS_CTS_ON) Status |= LS_CTS;
+    if (Temp & MS_DSR_ON) Status |= LS_DSR;
+    if (Temp & MS_RING_ON) Status |= LS_RI;
+    if (Temp & MS_RLSD_ON) Status |= LS_DCD;
     return Status;
 }
 
 void QextSerialPortPrivate::_q_onWinEvent(HANDLE h)
 {
     Q_Q(QextSerialPort);
-    if(h == overlap.hEvent) {
+    if (h == overlap.hEvent) {
         if (eventMask & EV_RXCHAR) {
             if (q->sender() != q && bytesAvailable_sys() > 0)
                 _q_canRead();
               Otherwise, leave them on there so they can finish.
             */
             qint64 totalBytesWritten = 0;
-            QList<OVERLAPPED*> overlapsToDelete;
-            foreach(OVERLAPPED* o, pendingWrites) {
+            QList<OVERLAPPED *> overlapsToDelete;
+            QWriteLocker writelocker(bytesToWriteLock);
+            foreach (OVERLAPPED *o, pendingWrites) {
                 DWORD numBytes = 0;
-                if (GetOverlappedResult(Win_Handle, o, & numBytes, false)) {
+                if (GetOverlappedResult(handle, o, &numBytes, false)) {
                     overlapsToDelete.append(o);
                     totalBytesWritten += numBytes;
-                } else if( GetLastError() != ERROR_IO_INCOMPLETE ) {
+                } else if (GetLastError() != ERROR_IO_INCOMPLETE) {
                     overlapsToDelete.append(o);
                     QESP_WARNING()<<"CommEvent overlapped write error:" << GetLastError();
                 }
             }
 
-            if (q->sender() != q && totalBytesWritten > 0) {
-                QWriteLocker writelocker(bytesToWriteLock);
+            if (q->sender() != q && totalBytesWritten > 0)
                 Q_EMIT q->bytesWritten(totalBytesWritten);
-                _bytesToWrite = 0;
-            }
 
-            foreach(OVERLAPPED* o, overlapsToDelete) {
+            foreach (OVERLAPPED *o, overlapsToDelete) {
                 OVERLAPPED *toDelete = pendingWrites.takeAt(pendingWrites.indexOf(o));
                 CloseHandle(toDelete->hEvent);
                 delete toDelete;
                 Q_EMIT q->dsrChanged(false);
         }
     }
-    WaitCommEvent(Win_Handle, &eventMask, &overlap);
+    WaitCommEvent(handle, &eventMask, &overlap);
 }
 
 void QextSerialPortPrivate::updatePortSettings()
         return;
 
     //fill struct : COMMCONFIG
-    if (settingsDirtyFlags & DFE_BaudRate) {
-        Win_CommConfig.dcb.BaudRate = Settings.BaudRate;
-    }
+    if (settingsDirtyFlags & DFE_BaudRate)
+        commConfig.dcb.BaudRate = settings.BaudRate;
     if (settingsDirtyFlags & DFE_Parity) {
-        Win_CommConfig.dcb.Parity = (BYTE)Settings.Parity;
-        Win_CommConfig.dcb.fParity = (Settings.Parity == PAR_NONE) ? FALSE : TRUE;
-    }
-    if (settingsDirtyFlags & DFE_DataBits) {
-        Win_CommConfig.dcb.ByteSize = (BYTE)Settings.DataBits;
+        commConfig.dcb.Parity = (BYTE)settings.Parity;
+        commConfig.dcb.fParity = (settings.Parity == PAR_NONE) ? FALSE : TRUE;
     }
+    if (settingsDirtyFlags & DFE_DataBits)
+        commConfig.dcb.ByteSize = (BYTE)settings.DataBits;
     if (settingsDirtyFlags & DFE_StopBits) {
-        switch (Settings.StopBits) {
+        switch (settings.StopBits) {
         case STOP_1:
-            Win_CommConfig.dcb.StopBits = ONESTOPBIT;
+            commConfig.dcb.StopBits = ONESTOPBIT;
             break;
         case STOP_1_5:
-            Win_CommConfig.dcb.StopBits = ONE5STOPBITS;
+            commConfig.dcb.StopBits = ONE5STOPBITS;
             break;
         case STOP_2:
-            Win_CommConfig.dcb.StopBits = TWOSTOPBITS;
+            commConfig.dcb.StopBits = TWOSTOPBITS;
             break;
         }
     }
     if (settingsDirtyFlags & DFE_Flow) {
-        switch(Settings.FlowControl) {
+        switch(settings.FlowControl) {
         /*no flow control*/
         case FLOW_OFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
+            commConfig.dcb.fOutxCtsFlow = FALSE;
+            commConfig.dcb.fRtsControl = RTS_CONTROL_DISABLE;
+            commConfig.dcb.fInX = FALSE;
+            commConfig.dcb.fOutX = FALSE;
             break;
         /*software (XON/XOFF) flow control*/
         case FLOW_XONXOFF:
-            Win_CommConfig.dcb.fOutxCtsFlow=FALSE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_DISABLE;
-            Win_CommConfig.dcb.fInX=TRUE;
-            Win_CommConfig.dcb.fOutX=TRUE;
+            commConfig.dcb.fOutxCtsFlow = FALSE;
+            commConfig.dcb.fRtsControl = RTS_CONTROL_DISABLE;
+            commConfig.dcb.fInX = TRUE;
+            commConfig.dcb.fOutX = TRUE;
             break;
         /*hardware flow control*/
         case FLOW_HARDWARE:
-            Win_CommConfig.dcb.fOutxCtsFlow=TRUE;
-            Win_CommConfig.dcb.fRtsControl=RTS_CONTROL_HANDSHAKE;
-            Win_CommConfig.dcb.fInX=FALSE;
-            Win_CommConfig.dcb.fOutX=FALSE;
+            commConfig.dcb.fOutxCtsFlow = TRUE;
+            commConfig.dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
+            commConfig.dcb.fInX = FALSE;
+            commConfig.dcb.fOutX = FALSE;
             break;
         }
     }
 
     //fill struct : COMMTIMEOUTS
     if (settingsDirtyFlags & DFE_TimeOut) {
-        if (_queryMode != QextSerialPort::EventDriven) {
-            int millisec = Settings.Timeout_Millisec;
+        if (queryMode != QextSerialPort::EventDriven) {
+            int millisec = settings.Timeout_Millisec;
             if (millisec == -1) {
-                Win_CommTimeouts.ReadIntervalTimeout = MAXDWORD;
-                Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
+                commTimeouts.ReadIntervalTimeout = MAXDWORD;
+                commTimeouts.ReadTotalTimeoutConstant = 0;
             } else {
-                Win_CommTimeouts.ReadIntervalTimeout = millisec;
-                Win_CommTimeouts.ReadTotalTimeoutConstant = millisec;
+                commTimeouts.ReadIntervalTimeout = millisec;
+                commTimeouts.ReadTotalTimeoutConstant = millisec;
             }
-            Win_CommTimeouts.ReadTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.WriteTotalTimeoutMultiplier = millisec;
-            Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
-        }
-        else {
-            Win_CommTimeouts.ReadIntervalTimeout = MAXDWORD;
-            Win_CommTimeouts.ReadTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.ReadTotalTimeoutConstant = 0;
-            Win_CommTimeouts.WriteTotalTimeoutMultiplier = 0;
-            Win_CommTimeouts.WriteTotalTimeoutConstant = 0;
+            commTimeouts.ReadTotalTimeoutMultiplier = 0;
+            commTimeouts.WriteTotalTimeoutMultiplier = millisec;
+            commTimeouts.WriteTotalTimeoutConstant = 0;
+        } else {
+            commTimeouts.ReadIntervalTimeout = MAXDWORD;
+            commTimeouts.ReadTotalTimeoutMultiplier = 0;
+            commTimeouts.ReadTotalTimeoutConstant = 0;
+            commTimeouts.WriteTotalTimeoutMultiplier = 0;
+            commTimeouts.WriteTotalTimeoutConstant = 0;
         }
     }
 
 
     if (settingsDirtyFlags & DFE_Settings_Mask)
-        SetCommConfig(Win_Handle, &Win_CommConfig, sizeof(COMMCONFIG));
+        SetCommConfig(handle, &commConfig, sizeof(COMMCONFIG));
     if ((settingsDirtyFlags & DFE_TimeOut))
-        SetCommTimeouts(Win_Handle, &Win_CommTimeouts);
+        SetCommTimeouts(handle, &commTimeouts);
     settingsDirtyFlags = 0;
 }

src/3rdparty/qextserialport/src/qextwineventnotifier_p.cpp

-/****************************************************************************
-** Copyright (c) 2000-2003 Wayne Roth
-** Copyright (c) 2004-2007 Stefan Sander
-** Copyright (c) 2007 Michal Policht
-** Copyright (c) 2008 Brandon Fosdick
-** Copyright (c) 2009-2010 Liam Staskawicz
-** Copyright (c) 2011 Debao Zhang
-** All right reserved.
-** Web: http://code.google.com/p/qextserialport/
-**
-** Permission is hereby granted, free of charge, to any person obtaining
-** a copy of this software and associated documentation files (the
-** "Software"), to deal in the Software without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Software, and to
-** permit persons to whom the Software is furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be
-** included in all copies or substantial portions of the Software.
-**
-** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**
-****************************************************************************/
-
-#include "qextwineventnotifier_p.h"
-#include <QtCore/QThread>
-#include <QtCore/QList>
-#include <QtCore/QMutex>
-#include <QtCore/QMutexLocker>
-#include <QtCore/QEvent>
-#include <QtCore/QDebug>
-#include <QtCore/QCoreApplication>
-
-class QextWinEventNotifierPrivate
-{
-    Q_DECLARE_PUBLIC(QextWinEventNotifier)
-public:
-    QextWinEventNotifierPrivate(HANDLE hEvent, QextWinEventNotifier * q)
-        :handleToEvent(hEvent), enabled(false), q_ptr(q)
-    {}
-
-    HANDLE handleToEvent;
-    bool enabled;
-private:
-    QextWinEventNotifier * q_ptr;
-};
-
-/*
-  \internal
-
-  \class QextWinEventNotifierThread
-
-  This class works more or less like an EventDispatcher.
-
-  The api function WaitForMultipleObjects() is used in the new thread
-  to wait for the  registered handle.
-*/
-class QextWinEventNotifierThread:public QThread
-{
-public:
-    explicit QextWinEventNotifierThread(QObject * parent=0);
-    ~QextWinEventNotifierThread();
-    void stop();
-    bool registerEventNotifier(QextWinEventNotifier * notifier);
-    void unregisterEventNotifier(QextWinEventNotifier * notifier);
-protected:
-    void run();
-private:
-    HANDLE hStopEvent; //stop thread when this event signaled.
-    HANDLE hUpdateEvent; //make sure eventlist updated.
-    QMutex mutex;
-    QList<QextWinEventNotifier *> winEventNotifierList;
-};
-
-Q_GLOBAL_STATIC(QextWinEventNotifierThread, notifierThread)
-
-QextWinEventNotifierThread::QextWinEventNotifierThread(QObject * parent)
-    :QThread(parent)
-{
-    hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-    hUpdateEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-    start();
-}
-
-QextWinEventNotifierThread::~QextWinEventNotifierThread()
-{
-    if (isRunning())
-        stop();
-    CloseHandle(hStopEvent);
-    CloseHandle(hUpdateEvent);
-}
-
-void QextWinEventNotifierThread::stop()
-{
-    {
-        QMutexLocker locker(&mutex);
-        SetEvent(hStopEvent);
-    }
-    wait();    /// Is this an good idea?
-}
-
-bool QextWinEventNotifierThread::registerEventNotifier(QextWinEventNotifier *notifier)
-{
-    QMutexLocker locker(&mutex);
-    if (!notifier) {
-        QESP_WARNING("QextWinEventNotifier: Internal error");
-        return false;
-    }
-    if (winEventNotifierList.contains(notifier))
-        return true;
-    if (winEventNotifierList.count() >= MAXIMUM_WAIT_OBJECTS - 3) {
-        QESP_WARNING("QextWinEventNotifier: Cannot have more than %d enabled at one time", MAXIMUM_WAIT_OBJECTS - 3);
-        return false;
-    }
-    winEventNotifierList.append(notifier);
-    SetEvent(hUpdateEvent);
-    return true;
-}
-
-void QextWinEventNotifierThread::unregisterEventNotifier(QextWinEventNotifier *notifier)
-{
-    QMutexLocker locker(&mutex);
-    if (!notifier) {
-        QESP_WARNING("QextWinEventNotifier: Internal error");
-        return;
-    }
-
-    int idx = winEventNotifierList.indexOf(notifier);
-    if (idx != -1) {
-        winEventNotifierList.takeAt(idx);
-        SetEvent(hUpdateEvent);
-    }
-}
-
-void QextWinEventNotifierThread::run()
-{
-    forever{
-        HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];
-        DWORD nCount = 0;
-        {
-            QMutexLocker locker(&mutex);
-            nCount = winEventNotifierList.count();
-            for (int i=0; i<(int)nCount; ++i)
-                pHandles[i] = winEventNotifierList.at(i)->handle();
-            pHandles[nCount] = hUpdateEvent;
-            pHandles[nCount+1] = hStopEvent;
-        }
-        DWORD ret = WaitForMultipleObjects(nCount+2, pHandles, FALSE, INFINITE);
-        if (ret >= WAIT_OBJECT_0 && ret < WAIT_OBJECT_0 + nCount) {
-            QEvent *evt = new QEvent(QEvent::User);
-            QMutexLocker locker(&mutex);
-            ResetEvent(pHandles[ret-WAIT_OBJECT_0]);
-            QObject * notifier = winEventNotifierList[ret - WAIT_OBJECT_0];
-            QCoreApplication::postEvent(notifier, evt);
-        }
-        else if (ret == WAIT_OBJECT_0 + nCount) {
-            //ResetEvent(hUpdateEvent);
-        }
-        else if (ret == WAIT_OBJECT_0 + nCount + 1) {
-            //qDebug()<<"quit...";
-            return;
-        }
-    }
-}
-
-/*!
-    \internal
-    \class QextWinEventNotifier
-    \brief The QextWinEventNotifier class provides support for the Windows Wait functions.
-
-    The QextWinEventNotifier class makes it possible to use the wait
-    functions on windows in a asynchronous manner. With this class
-    you can register a HANDLE to an event and get notification when
-    that event becomes signalled.
-
-    \bold Note: If it is a manual reset event ,it will be reset before
-    the notification. This is different from QWinEventNotifier.
-
-    \bold Note: All the registered handles will be waited under a new thread.
-    This is different from QWinEventNotifier whose event handle will be waited
-    in its affinal thread.
-*/
-
-QextWinEventNotifier::QextWinEventNotifier(QObject *parent)
-    : QObject(parent), d_ptr(new QextWinEventNotifierPrivate(0, this))
-{}
-
-QextWinEventNotifier::QextWinEventNotifier(HANDLE hEvent, QObject *parent)
- : QObject(parent), d_ptr(new QextWinEventNotifierPrivate(hEvent, this))
-{
-    setEnabled(true);
-}
-
-QextWinEventNotifier::~QextWinEventNotifier()
-{
-    setEnabled(false);
-}
-
-void QextWinEventNotifier::setHandle(HANDLE hEvent)
-{
-    setEnabled(false);
-    Q_D(QextWinEventNotifier);
-    d->handleToEvent = hEvent;
-}
-
-HANDLE  QextWinEventNotifier::handle() const
-{
-    return d_func()->handleToEvent;
-}
-
-bool QextWinEventNotifier::isEnabled() const
-{
-    return d_func()->enabled;
-}
-
-void QextWinEventNotifier::setEnabled(bool enable)
-{
-    Q_D(QextWinEventNotifier);
-
-    if (d->enabled == enable)
-        return;
-    d->enabled = enable;
-
-    if (d->enabled)
-        notifierThread()->registerEventNotifier(this);
-    else
-        notifierThread()->unregisterEventNotifier(this);
-}
-
-bool QextWinEventNotifier::event(QEvent * e)
-{
-    Q_D(QextWinEventNotifier);
-    QObject::event(e);
-    if (e->type() == QEvent::User) {
-        emit activated(d->handleToEvent);
-        return true;
-    }
-    return false;
-}
-

src/3rdparty/qextserialport/src/qextwineventnotifier_p.h

-/****************************************************************************
-** Copyright (c) 2000-2003 Wayne Roth
-** Copyright (c) 2004-2007 Stefan Sander
-** Copyright (c) 2007 Michal Policht
-** Copyright (c) 2008 Brandon Fosdick
-** Copyright (c) 2009-2010 Liam Staskawicz
-** Copyright (c) 2011 Debao Zhang
-** All right reserved.
-** Web: http://code.google.com/p/qextserialport/
-**
-** Permission is hereby granted, free of charge, to any person obtaining
-** a copy of this software and associated documentation files (the
-** "Software"), to deal in the Software without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Software, and to
-** permit persons to whom the Software is furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be
-** included in all copies or substantial portions of the Software.
-**
-** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-** NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-** LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-** OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-** WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**
-****************************************************************************/
-
-#ifndef QEXTWINEVENTNOTIFIER_P_H_
-#define QEXTWINEVENTNOTIFIER_P_H_
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the QESP API.  It exists for the convenience
-// of other QESP classes.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <QtCore/QObject>
-#include <QtCore/qt_windows.h>
-#include "qextserialport_global.h"
-
-class QextWinEventNotifierPrivate;
-class QEXTSERIALPORT_EXPORT QextWinEventNotifier : public QObject
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE(QextWinEventNotifier)
-
-public:
-    explicit QextWinEventNotifier(QObject *parent = 0);
-    explicit QextWinEventNotifier(HANDLE hEvent, QObject *parent = 0);
-    ~QextWinEventNotifier();
-
-    void setHandle(HANDLE hEvent);
-    HANDLE handle() const;
-
-    bool isEnabled() const;
-
-public Q_SLOTS:
-    void setEnabled(bool enable);
-
-Q_SIGNALS:
-    void activated(HANDLE hEvent);
-
-protected:
-    bool event(QEvent * e);
-
-private:
-    Q_DISABLE_COPY(QextWinEventNotifier)
-    QextWinEventNotifierPrivate * d_ptr;
-};
-
-#endif // QEXTWINEVENTNOTIFIER_P_H_

src/3rdparty/qextserialport/tests/qextwineventnotifier/tst_qextwineventnotifier.cpp

-#include "qextwineventnotifier_p.h"
-#include <QtTest/QtTest>
-#include <QtCore/QTimer>
-
-class tst_QextWinEventNotifier : public QObject
-{
-    Q_OBJECT
-
-public:
-    tst_QextWinEventNotifier(){}
-    ~tst_QextWinEventNotifier(){}
-
-    void initTestCase(){}
-    void cleanupTestCase(){}
-    void init(){}
-    void cleanup(){}
-
-protected slots:
-    void simple_activated();
-    void simple_timerSet();
-
-private slots:
-    void empty();
-    void simple();
-
-private:
-    HANDLE simpleHEvent;
-    int simpleActivated;
-};
-
-void tst_QextWinEventNotifier::simple_activated()
-{
-    ++simpleActivated;
-    ResetEvent((HANDLE)simpleHEvent);
-    QTestEventLoop::instance().exitLoop();
-}
-
-void tst_QextWinEventNotifier::simple_timerSet()
-{
-    SetEvent((HANDLE)simpleHEvent);
-}
-
-void tst_QextWinEventNotifier::empty()
-{
-    QextWinEventNotifier n1, n2, n3;
-    n1.setEnabled(true);
-    n2.setEnabled(true);
-    n3.setEnabled(true);
-    n1.setEnabled(false);
-}
-
-void tst_QextWinEventNotifier::simple()
-{
-    simpleHEvent = CreateEvent(0, TRUE, FALSE, 0);
-    QVERIFY(simpleHEvent);
-
-    QextWinEventNotifier n(simpleHEvent);
-    QObject::connect(&n, SIGNAL(activated(HANDLE)), this, SLOT(simple_activated()));
-
-    simpleActivated = 0;
-    SetEvent((HANDLE)simpleHEvent);
-    QTestEventLoop::instance().enterLoop(30);
-    if (QTestEventLoop::instance().timeout())
-        QFAIL("Timed out");
-    QVERIFY(simpleActivated == 1);
-
-    simpleActivated = 0;
-    QTimer::singleShot(3000, this, SLOT(simple_timerSet()));
-    QTestEventLoop::instance().enterLoop(30);
-    if (QTestEventLoop::instance().timeout())
-        QFAIL("Timed out");
-    QVERIFY(simpleActivated == 1);
-}
-
-QTEST_MAIN(tst_QextWinEventNotifier)
-
-#include "tst_qextwineventnotifier.moc"

src/3rdparty/qextserialport/tests/tests.pro

-TEMPLATE=subdirs
-win32:SUBDIRS += qextwineventnotifier

src/Typica.pro

 QT += scripttools
 QT += webkit
 
-include(3rdparty/qextserialport/src/qextserialport.pri)
+CONFIG += extserialport
 
 TEMPLATE = app
 TARGET =