diff --git a/src/backend/datasources/LiveDataSource.cpp b/src/backend/datasources/LiveDataSource.cpp
index d9a13de92..60df60251 100644
--- a/src/backend/datasources/LiveDataSource.cpp
+++ b/src/backend/datasources/LiveDataSource.cpp
@@ -1,1015 +1,1024 @@
 /***************************************************************************
 File		: LiveDataSource.cpp
 Project		: LabPlot
 Description	: Represents live data source
 --------------------------------------------------------------------
 Copyright	: (C) 2009-2017 Alexander Semke (alexander.semke@web.de)
 Copyright   : (C) 2017 Fabian Kristof (fkristofszabolcs@gmail.com)
 
 ***************************************************************************/
 
 /***************************************************************************
 *                                                                         *
 *  This program is free software; you can redistribute it and/or modify   *
 *  it under the terms of the GNU General Public License as published by   *
 *  the Free Software Foundation; either version 2 of the License, or      *
 *  (at your option) any later version.                                    *
 *                                                                         *
 *  This program is distributed in the hope that it will be useful,        *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
 *  GNU General Public License for more details.                           *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
 *   Boston, MA  02110-1301  USA                                           *
 *                                                                         *
 ***************************************************************************/
 
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/datasources/filters/AsciiFilter.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "backend/datasources/filters/BinaryFilter.h"
 #include "backend/core/Project.h"
 #include "kdefrontend/spreadsheet/PlotDataDialog.h"
 
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
 
 #include <QFileInfo>
 #include <QDateTime>
 #include <QProcess>
 #include <QDir>
 #include <QMenu>
 #include <QFileSystemWatcher>
 #include <QFile>
 #include <QTimer>
 #include <QMessageBox>
 
 #include <QtSerialPort/QSerialPort>
 #include <QtSerialPort/QSerialPortInfo>
 #include <QTcpSocket>
 #include <QUdpSocket>
 
 #include <QIcon>
 #include <QAction>
 #include <KLocale>
 
 #include <QDebug>
 
 /*!
   \class LiveDataSource
   \brief Represents data stored in a file. Reading and writing is done with the help of appropriate I/O-filters.
 
   \ingroup datasources
 */
 LiveDataSource::LiveDataSource(AbstractScriptingEngine* engine, const QString& name, bool loading)
 	: Spreadsheet(engine, name, loading),
 	  m_fileType(Ascii),
 	  m_fileWatched(false),
 	  m_fileLinked(false),
 	  m_paused(false),
 	  m_prepared(false),
 	  m_keepLastValues(false),
 	  m_bytesRead(0),
 	  m_filter(nullptr),
 	  m_updateTimer(new QTimer(this)),
 	  m_fileSystemWatcher(nullptr),
 	  m_file(nullptr),
 	  m_localSocket(nullptr),
 	  m_tcpSocket(nullptr),
 	  m_udpSocket(nullptr),
 	  m_serialPort(nullptr),
 	  m_device(nullptr) {
 
 	initActions();
 	connect(m_updateTimer, SIGNAL(timeout()), this, SLOT(read()));
 }
 
 LiveDataSource::~LiveDataSource() {
 	if (m_filter)
 		delete m_filter;
 
 	if (m_fileSystemWatcher)
 		delete m_fileSystemWatcher;
 
 	if (m_file)
 		delete m_file;
 
 	if (m_localSocket)
 		delete m_localSocket;
 
 	if (m_tcpSocket)
 		delete m_tcpSocket;
 
 	if (m_serialPort)
 		delete m_serialPort;
 
 	delete m_updateTimer;
 }
 
 /*!
  * depending on the update type, periodically or on data changes, starts the timer or activates the file watchers, respectively.
  */
 void LiveDataSource::ready() {
 	if (m_updateType == TimeInterval)
 		m_updateTimer->start(m_updateInterval);
 	else
 		watch();
 }
 
 void LiveDataSource::initActions() {
 	m_reloadAction = new QAction(QIcon::fromTheme("view-refresh"), i18n("Reload"), this);
 	connect(m_reloadAction, SIGNAL(triggered()), this, SLOT(read()));
 
 	m_toggleLinkAction = new QAction(i18n("Link the file"), this);
 	m_toggleLinkAction->setCheckable(true);
 	connect(m_toggleLinkAction, SIGNAL(triggered()), this, SLOT(linkToggled()));
 
 	m_plotDataAction = new QAction(QIcon::fromTheme("office-chart-line"), i18n("Plot data"), this);
 	connect(m_plotDataAction, SIGNAL(triggered()), this, SLOT(plotData()));
 }
 
 QWidget* LiveDataSource::view() const {
 	if (!m_view)
 		m_view = new SpreadsheetView(const_cast<LiveDataSource*>(this), true);
 	return m_view;
 }
 
 /*!
  * \brief Returns a list with the names of the available ports
  */
 QStringList LiveDataSource::availablePorts() {
 	QStringList ports;
 	qDebug() << "available ports count:" << QSerialPortInfo::availablePorts().size();
 
 	for(const QSerialPortInfo& sp : QSerialPortInfo::availablePorts()) {
 		ports.append(sp.portName());
 
 		qDebug() << sp.description();
 		qDebug() << sp.manufacturer();
 		qDebug() << sp.portName();
 		qDebug() << sp.serialNumber();
 		qDebug() << sp.systemLocation();
 	}
 
 	return ports;
 }
 
 /*!
  * \brief Returns a list with the supported baud rates
  */
 QStringList LiveDataSource::supportedBaudRates() {
 	QStringList baudRates;
 
 	for(const auto& baud : QSerialPortInfo::standardBaudRates())
 		baudRates.append(QString::number(baud));
 	return baudRates;
 }
 
 /*!
  * \brief Updates this data source at this moment
  */
 void LiveDataSource::updateNow() {
 	m_updateTimer->stop();
 	read();
 
 	//restart the timer after update
 	if (m_updateType == TimeInterval)
 		m_updateTimer->start(m_updateInterval);
 }
 
 /*!
  * \brief Continue reading from the live data source after it was paused.
  */
 void LiveDataSource::continueReading() {
 	m_paused = false;
 	if (m_updateType == TimeInterval)
 		m_updateTimer->start(m_updateInterval);
 	else if (m_updateType == NewData)
 		connect(m_fileSystemWatcher, SIGNAL(fileChanged(QString)), this, SLOT(read()));
 }
 
 /*!
  * \brief Pause the reading of the live data source.
  */
 void LiveDataSource::pauseReading() {
 	m_paused = true;
 	if (m_updateType == TimeInterval)
 		m_updateTimer->stop();
 	else if (m_updateType == NewData)
 		disconnect(m_fileSystemWatcher, SIGNAL(fileChanged(QString)), this, SLOT(read()));
 }
 
 /*!
   returns the list with all supported data file formats.
 */
 QStringList LiveDataSource::fileTypes() {
 // see LiveDataSource::FileType
 	return (QStringList()<< i18n("ASCII data")
 	        << i18n("Binary data")
 	        << i18n("Image")
 	        << i18n("Hierarchical Data Format (HDF)")
 	        << i18n("Network Common Data Format (NetCDF)")
 //		<< "CDF"
 	        << i18n("Flexible Image Transport System Data Format (FITS)")
 //		<< i18n("Sound")
 	       );
 }
 
 void LiveDataSource::setFileName(const QString& name) {
 	m_fileName = name;
 }
 
 QString LiveDataSource::fileName() const {
 	return m_fileName;
 }
 
 /*!
  * \brief Sets the local socket's server name to name
  * \param name
  */
 void LiveDataSource::setLocalSocketName(const QString & name) {
 	m_localSocketName = name;
 }
 
 QString LiveDataSource::localSocketName() const {
 	return m_localSocketName;
 }
 
 void LiveDataSource::setFileType(const FileType type) {
 	m_fileType = type;
 }
 
 LiveDataSource::FileType LiveDataSource::fileType() const {
 	return m_fileType;
 }
 
 void LiveDataSource::setFilter(AbstractFileFilter* f) {
 	m_filter = f;
 }
 
 AbstractFileFilter* LiveDataSource::filter() const {
 	return m_filter;
 }
 
 /*!
   sets whether the file should be watched or not.
   In the first case the data source will be automatically updated on file changes.
 */
 void LiveDataSource::setFileWatched(const bool b) {
 	m_fileWatched = b;
 }
 
 bool LiveDataSource::isFileWatched() const {
 	return m_fileWatched;
 }
 
 /*!
  * \brief Sets whether we'll keep the last values or append it to the previous ones
  * \param keepLastValues
  */
 void LiveDataSource::setKeepLastValues(const bool keepLastValues) {
 	m_keepLastValues = keepLastValues;
 }
 
 bool LiveDataSource::keepLastValues() const {
 	return m_keepLastValues;
 }
 
 /*!
  * \brief Sets the serial port's baud rate
  * \param baudrate
  */
 void LiveDataSource::setBaudRate(const int baudrate) {
 	m_baudRate = baudrate;
 }
 
 int LiveDataSource::baudRate() const {
 	return m_baudRate;
 }
 
 /*!
  * \brief Sets the source's update interval to \c interval
  * \param interval
  */
 void LiveDataSource::setUpdateInterval(const int interval) {
 	m_updateInterval = interval;
 	m_updateTimer->start(m_updateInterval);
 }
 
 int LiveDataSource::updateInterval() const {
 	return m_updateInterval;
 }
 
 /*!
  * \brief Sets how many values we should store
  * \param keepnvalues
  */
 void LiveDataSource::setKeepNvalues(const int keepnvalues) {
 	m_keepNvalues = keepnvalues;
 }
 
 int LiveDataSource::keepNvalues() const {
 	return m_keepNvalues;
 }
 
 /*!
  * \brief Sets the network socket's port to port
  * \param port
  */
 void LiveDataSource::setPort(const int port) {
 	m_port = port;
 }
 
 void LiveDataSource::setBytesRead(const qint64 bytes) {
 	m_bytesRead = bytes;
 }
 
 int LiveDataSource::bytesRead() const {
 	return m_bytesRead;
 }
 
 int LiveDataSource::port() const {
 	return m_port;
 }
 
 /*!
  * \brief Sets the serial port's name to name
  * \param name
  */
 void LiveDataSource::setSerialPort(const QString &name) {
 	m_serialPortName = name;
 }
 
 QString LiveDataSource::serialPortName() const {
 	return m_serialPortName;
 }
 
 bool LiveDataSource::isPaused() const {
 	return m_paused;
 }
 
 /*!
  * \brief Sets the sample rate to samplerate
  * \param samplerate
  */
 void LiveDataSource::setSampleRate(const int samplerate) {
 	m_sampleRate = samplerate;
 }
 
 int LiveDataSource::sampleRate() const {
 	return m_sampleRate;
 }
 
 /*!
  * \brief Sets the source's type to sourcetype
  * \param sourcetype
  */
 void LiveDataSource::setSourceType(const SourceType sourcetype) {
 	m_sourceType = sourcetype;
 }
 
 LiveDataSource::SourceType LiveDataSource::sourceType() const {
 	return m_sourceType;
 }
 
 /*!
  * \brief Sets the source's reading type to readingType
  * \param readingType
  */
 void LiveDataSource::setReadingType(const ReadingType readingType) {
 	m_readingType = readingType;
 }
 
 LiveDataSource::ReadingType LiveDataSource::readingType() const {
 	return m_readingType;
 }
 
 /*!
  * \brief Sets the source's update type to updatetype and handles this change
  * \param updatetype
  */
 void LiveDataSource::setUpdateType(const UpdateType updatetype) {
 	if (updatetype == NewData) {
 		m_updateTimer->stop();
 		if (m_fileSystemWatcher == nullptr)
 			watch();
 		else
 			connect(m_fileSystemWatcher, SIGNAL(fileChanged(QString)), this, SLOT(read()));
 	} else {
 		if (m_fileSystemWatcher)
 			disconnect(m_fileSystemWatcher, SIGNAL(fileChanged(QString)), this, SLOT(read()));
 	}
 	m_updateType = updatetype;
 }
 
 LiveDataSource::UpdateType LiveDataSource::updateType() const {
 	return m_updateType;
 }
 
 /*!
  * \brief Sets the network socket's host
  * \param host
  */
 void LiveDataSource::setHost(const QString & host) {
 	m_host = host;
 }
 
 QString LiveDataSource::host() const {
 	return m_host;
 }
 
 /*!
   sets whether only a link to the file is saved in the project file (\c b=true)
   or the whole content of the file (\c b=false).
 */
 void LiveDataSource::setFileLinked(const bool b) {
 	m_fileLinked = b;
 }
 
 /*!
   returns \c true if only a link to the file is saved in the project file.
   \c false otherwise.
 */
 bool LiveDataSource::isFileLinked() const {
 	return m_fileLinked;
 }
 
 QIcon LiveDataSource::icon() const {
 	QIcon icon;
 	if (m_fileType == LiveDataSource::Ascii)
 		icon = QIcon::fromTheme("text-plain");
 	else if (m_fileType == LiveDataSource::Binary)
 		icon = QIcon::fromTheme("application-octet-stream");
 	else if (m_fileType == LiveDataSource::Image)
 		icon = QIcon::fromTheme("image-x-generic");
 	// TODO: HDF, NetCDF, FITS, etc.
 
 	return icon;
 }
 
 QMenu* LiveDataSource::createContextMenu() {
 	QMenu* menu = AbstractPart::createContextMenu();
 
 	QAction* firstAction = 0;
 	// if we're populating the context menu for the project explorer, then
 	//there're already actions available there. Skip the first title-action
 	//and insert the action at the beginning of the menu.
 	if (menu->actions().size()>1)
 		firstAction = menu->actions().at(1);
 
 	menu->insertAction(firstAction, m_plotDataAction);
 	menu->insertSeparator(firstAction);
 
 	//TODO: doesnt' always make sense...
 // 	if (!m_fileWatched)
 // 		menu->insertAction(firstAction, m_reloadAction);
 //
 // 	m_toggleWatchAction->setChecked(m_fileWatched);
 // 	menu->insertAction(firstAction, m_toggleWatchAction);
 //
 // 	m_toggleLinkAction->setChecked(m_fileLinked);
 // 	menu->insertAction(firstAction, m_toggleLinkAction);
 
 	return menu;
 }
 
 //##############################################################################
 //#################################  SLOTS  ####################################
 //##############################################################################
 
 /*
  * called periodically or on new data changes (file changed, new data in the socket, etc.)
  */
 void LiveDataSource::read() {
 	if (m_filter == nullptr)
 		return;
 
 	//initialize the device (file, socket, serial port), when calling this function for the first time
 	if (!m_prepared) {
 		switch (m_sourceType) {
 		case FileOrPipe:
 			m_file = new QFile(m_fileName);
 			m_device = m_file;
 			break;
 		case NetworkTcpSocket:
 			m_tcpSocket = new QTcpSocket(this);
 			m_tcpSocket->connectToHost(m_host, m_port, QIODevice::ReadOnly);
 			m_device = m_tcpSocket;
 
 			qDebug() << "socket state before preparing: " << m_tcpSocket->state();
 			connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(readyRead()));
 			connect(m_tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(tcpSocketError(QAbstractSocket::SocketError)));
 			qDebug() << "socket state after preparing: " << m_tcpSocket->state();
 
 			break;
 		case NetworkUdpSocket:
 			m_udpSocket = new QUdpSocket(this);
-			m_udpSocket->connectToHost(m_host, m_port, QIODevice::ReadOnly);
+
+            m_udpSocket->bind(QHostAddress(m_host), m_port);
 			qDebug() << "socket state before preparing: " << m_udpSocket->state();
+            m_udpSocket->connectToHost(m_host, m_port);
+
 			m_device = m_udpSocket;
-			m_udpSocket->waitForConnected(1000);
 			connect(m_udpSocket, SIGNAL(readyRead()), this, SLOT(readyRead()));
 			connect(m_udpSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(tcpSocketError(QAbstractSocket::SocketError)));
 			qDebug() << "socket state after preparing: " << m_udpSocket->state();
 
 			break;
 		case LocalSocket:
 			m_localSocket = new QLocalSocket(this);
 			qDebug() << "socket state before preparing: " << m_localSocket->state();
 			m_localSocket->connectToServer(m_localSocketName, QLocalSocket::ReadOnly);
 			qDebug() << "socket state after preparing: " << m_localSocket->state();
 
 			m_device = m_localSocket;
 			connect(m_localSocket, SIGNAL(readyRead()), this, SLOT(readyRead()));
 			connect(m_localSocket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(localSocketError(QLocalSocket::LocalSocketError)));
 
 			break;
 		case SerialPort:
 			m_serialPort = new QSerialPort;
 			m_device = m_serialPort;
 			m_serialPort->setBaudRate(m_baudRate);
 			m_serialPort->setPortName(m_serialPortName);
 			connect(m_serialPort, SIGNAL(error(QSerialPort::SerialPortError)), this, SLOT(serialPortError(QSerialPort::SerialPortError)));
 			connect(m_serialPort, SIGNAL(readyRead()), this, SLOT(readyRead()));
 			break;
 		}
 		m_prepared = true;
 	}
 
 	qint64 bytes = 0;
 
 	switch (m_sourceType) {
 	case FileOrPipe:
 		switch (m_fileType) {
 		case Ascii:
 			qDebug() << "Reading live ascii file.." ;
 			bytes = dynamic_cast<AsciiFilter*>(m_filter)->readFromLiveDevice(*m_file, this, m_bytesRead);
 			m_bytesRead += bytes;
 			qDebug() << "Read " << bytes << " bytes, in total: " << m_bytesRead;
 
 			break;
 		case Binary:
 			//bytes = dynamic_cast<BinaryFilter*>(m_filter)->readFromLiveDevice(*m_file, this, m_bytesRead);
 			m_bytesRead += bytes;
 		default:
 			break;
 		}
 		break;
 	case NetworkTcpSocket:
 		DEBUG("reading from a TCP socket");
 		qDebug() << "reading from a TCP socket before abort: " << m_tcpSocket->state();
 		m_tcpSocket->abort();
 		m_tcpSocket->connectToHost(m_host, m_port, QIODevice::ReadOnly);
 		qDebug() << "reading from a TCP socket after reconnect: " << m_tcpSocket->state();
 
 		break;
 	case NetworkUdpSocket:
 		DEBUG("reading from a UDP socket");
+        qDebug() << "reading from a UDP socket before abort: " << m_udpSocket->state();
 		m_udpSocket->abort();
-		m_udpSocket->connectToHost(m_host, m_port, QIODevice::ReadOnly);
+        m_udpSocket->bind(QHostAddress(m_host), m_port);
+        m_udpSocket->connectToHost(m_host, m_port);
+
+        qDebug() << "reading from a UDP socket after reconnect: " << m_udpSocket->state();
+
 		break;
 	case LocalSocket:
 		DEBUG("reading from a local socket");
 		qDebug() << "reading from a local socket before abort: " << m_localSocket->state();
 		m_localSocket->abort();
 		m_localSocket->connectToServer(m_localSocketName, QLocalSocket::ReadOnly);
 		qDebug() << "reading from a local socket after reconnect: " << m_localSocket->state();
 		break;
 	case SerialPort:
 		DEBUG("reading from the serial port");
 		m_serialPort->setBaudRate(m_baudRate);
 		m_serialPort->setPortName(m_serialPortName);
 		m_device = m_serialPort;
 		//TODO
 		break;
 	}
 }
 
 /*!
  * Slot for the signal that is emitted once every time new data is available for reading from the device.
  * It will only be emitted again once new data is available, such as when a new payload of network data has arrived on the network socket,
  * or when a new block of data has been appended to your device.
  */
 void LiveDataSource::readyRead() {
 	DEBUG("Got new data from the device");
+    qDebug()<< "Got new data from the device";
+
 	if (m_fileType == Ascii)
 		dynamic_cast<AsciiFilter*>(m_filter)->readFromLiveDeviceNotFile(*m_device, this);
 // 	else if (m_fileType == Binary)
 	//  dynamic_cast<BinaryFilter*>(m_filter)->readFromLiveDeviceNotFile(*m_device, this);
 
 	//since we won't have the timer to call read() where we create new connections
 	//for sequencial devices in read() we just request data/connect to servers
 	if (m_updateType == NewData)
 		read();
 }
 
 void LiveDataSource::localSocketError(QLocalSocket::LocalSocketError socketError) {
 	/*disconnect(m_localSocket, SIGNAL(error(QLocalSocket::LocalSocketError)), this, SLOT(localSocketError(QLocalSocket::LocalSocketError)));
 	disconnect(m_localSocket, SIGNAL(readyRead()), this, SLOT(readyRead()));*/
 
 	/*switch (socketError) {
 	case QLocalSocket::ServerNotFoundError:
 		QMessageBox::critical(0, i18n("Local Socket Error"),
 		                      i18n("The socket was not found. Please check the socket name."));
 		break;
 	case QLocalSocket::ConnectionRefusedError:
 		QMessageBox::critical(0, i18n("Local Socket Error"),
 		                      i18n("The connection was refused by the peer"));
 		break;
 	case QLocalSocket::PeerClosedError:
 		QMessageBox::critical(0, i18n("Local Socket Error"),
 		                      i18n("The socket has closed the connection."));
 		break;
 	default:
 		QMessageBox::critical(0, i18n("Local Socket Error"),
 		                      i18n("The following error occurred: %1.").arg(m_localSocket->errorString()));
 	}*/
 }
 
 void LiveDataSource::tcpSocketError(QAbstractSocket::SocketError socketError) {
 	/*switch (socketError) {
 	case QAbstractSocket::ConnectionRefusedError:
 		QMessageBox::critical(0, i18n("TCP Socket Error"),
 		                      i18n("The connection was refused by the peer. Make sure the server is running and check the host name and port settings."));
 		break;
 	case QAbstractSocket::RemoteHostClosedError:
 		QMessageBox::critical(0, i18n("TCP Socket Error"),
 		                      i18n("The remote host closed the connection."));
 		break;
 	case QAbstractSocket::HostNotFoundError:
 		QMessageBox::critical(0, i18n("TCP Socket Error"),
 		                      i18n("The host was not found. Please check the host name and port settings."));
 		break;
 	default:
 		QMessageBox::critical(0, i18n("TCP Socket Error"),
 		                      i18n("The following error occurred: %1.").arg(m_tcpSocket->errorString()));
 	}*/
 }
 
 void LiveDataSource::serialPortError(QSerialPort::SerialPortError serialPortError) {
 	switch (serialPortError) {
 	case QSerialPort::DeviceNotFoundError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("Failed to open the device."));
 		break;
 	case QSerialPort::PermissionError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("Failed to open the device. Please check your permissions on this device."));
 		break;
 	case QSerialPort::OpenError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("Device already opened."));
 		break;
 	case QSerialPort::NotOpenError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("The device is not opened."));
 		break;
 	case QSerialPort::ReadError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("Failed to read data."));
 		break;
 	case QSerialPort::ResourceError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("Failed to read data. The device is removed."));
 		break;
 	case QSerialPort::TimeoutError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("The device timed out."));
 		break;
 	default:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("The following error occurred: %1.").arg(m_serialPort->errorString()));
 		break;
 	}
 }
 
 void LiveDataSource::watchToggled() {
 	m_fileWatched = !m_fileWatched;
 	watch();
 	project()->setChanged(true);
 }
 
 void LiveDataSource::linkToggled() {
 	m_fileLinked = !m_fileLinked;
 	project()->setChanged(true);
 }
 
 //watch the file upon reading for changes if required
 void LiveDataSource::watch() {
 	if (m_fileWatched) {
 		if (!m_fileSystemWatcher) {
 			m_fileSystemWatcher = new QFileSystemWatcher;
 			connect (m_fileSystemWatcher, SIGNAL(fileChanged(QString)), this, SLOT(read()));
 		}
 
 		if ( !m_fileSystemWatcher->files().contains(m_fileName) )
 			m_fileSystemWatcher->addPath(m_fileName);
 	} else {
 		if (m_fileSystemWatcher)
 			m_fileSystemWatcher->removePath(m_fileName);
 	}
 }
 
 /*!
     returns a string containing the general information about the file \c name
     and some content specific information
     (number of columns and lines for ASCII, color-depth for images etc.).
  */
 QString LiveDataSource::fileInfoString(const QString &name) {
 	QString infoString;
 	QFileInfo fileInfo;
 	QString fileTypeString;
 	QIODevice *file = new QFile(name);
 
 	QString fileName;
 	if (name.at(0) != QDir::separator())
 		fileName = QDir::homePath() + QDir::separator() + name;
 	else
 		fileName = name;
 
 	if(file==0)
 		file = new QFile(fileName);
 
 	if (file->open(QIODevice::ReadOnly)) {
 		QStringList infoStrings;
 
 		//general information about the file
 		infoStrings << "<u><b>" + fileName + "</b></u><br>";
 		fileInfo.setFile(fileName);
 
 		infoStrings << i18n("Readable: %1", fileInfo.isReadable() ? i18n("yes") : i18n("no"));
 		infoStrings << i18n("Writable: %1", fileInfo.isWritable() ? i18n("yes") : i18n("no"));
 		infoStrings << i18n("Executable: %1", fileInfo.isExecutable() ? i18n("yes") : i18n("no"));
 
 		infoStrings << i18n("Created: %1", fileInfo.created().toString());
 		infoStrings << i18n("Last modified: %1", fileInfo.lastModified().toString());
 		infoStrings << i18n("Last read: %1", fileInfo.lastRead().toString());
 		infoStrings << i18n("Owner: %1", fileInfo.owner());
 		infoStrings << i18n("Group: %1", fileInfo.group());
 		infoStrings << i18n("Size: %1", i18np("%1 cByte", "%1 cBytes", fileInfo.size()));
 
 #ifdef HAVE_FITS
 		if (fileName.endsWith(QLatin1String(".fits"))) {
 			FITSFilter* fitsFilter = new FITSFilter;
 
 			infoStrings << i18n("Images: %1", QString::number(fitsFilter->imagesCount(fileName) ));
 			infoStrings << i18n("Tables: %1", QString::number(fitsFilter->tablesCount(fileName) ));
 
 			delete fitsFilter;
 		}
 #endif
 
 		// file type and type specific information about the file
 #ifdef Q_OS_LINUX
 		QProcess *proc = new QProcess();
 		QStringList args;
 		args<<"-b"<<fileName;
 		proc->start( "file", args);
 
 		if(proc->waitForReadyRead(1000) == false)
 			infoStrings << i18n("Could not open file %1 for reading.", fileName);
 		else {
 			fileTypeString = proc->readLine();
 			if( fileTypeString.contains(i18n("cannot open")) )
 				fileTypeString="";
 			else {
 				fileTypeString.remove(fileTypeString.length()-1,1);	// remove '\n'
 			}
 		}
 		infoStrings << i18n("File type: %1", fileTypeString);
 #endif
 
 		//TODO depending on the file type, generate additional information about the file:
 		//Number of lines for ASCII, color-depth for images etc. Use the specific filters here.
 		// port the old labplot1.6 code.
 		if( fileTypeString.contains("ASCII")) {
 			infoStrings << "<br/>";
 			//TODO: consider choosen separator
 			infoStrings << i18n("Number of columns: %1", AsciiFilter::columnNumber(fileName));
 
 			infoStrings << i18n("Number of lines: %1", AsciiFilter::lineNumber(fileName));
 		}
 		infoString += infoStrings.join("<br/>");
 	} else
 		infoString += i18n("Could not open file %1 for reading.", fileName);
 
 	return infoString;
 }
 
 void LiveDataSource::plotData() {
 	PlotDataDialog* dlg = new PlotDataDialog(this);
 	dlg->exec();
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 /*!
   Saves as XML.
  */
 void LiveDataSource::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("liveDataSource");
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//general
 	writer->writeStartElement("general");
 	writer->writeAttribute("fileName", m_fileName);
 	writer->writeAttribute("fileType", QString::number(m_fileType));
 	writer->writeAttribute("fileWatched", QString::number(m_fileWatched));
 	writer->writeAttribute("fileLinked", QString::number(m_fileLinked));
 	writer->writeAttribute("updateType", QString::number(m_updateType));
 	writer->writeAttribute("readingType", QString::number(m_readingType));
 	writer->writeAttribute("sourceType", QString::number(m_sourceType));
 	writer->writeAttribute("keepValues", QString::number(m_keepNvalues));
 
 	if (m_updateType == TimeInterval)
 		writer->writeAttribute("updateInterval", QString::number(m_updateInterval));
 
 	if (m_readingType != TillEnd)
 		writer->writeAttribute("sampleRate", QString::number(m_sampleRate));
 
 	switch (m_sourceType) {
 	case SerialPort:
 		writer->writeAttribute("baudRate", QString::number(m_baudRate));
 		writer->writeAttribute("serialPortName", m_serialPortName);
 
 		break;
 	case NetworkTcpSocket:
 	case NetworkUdpSocket:
 		writer->writeAttribute("host", m_host);
 		writer->writeAttribute("port", QString::number(m_port));
 		break;
 	case FileOrPipe:
 		break;
 	case LocalSocket:
 		break;
 	default:
 		break;
 	}
 
 	writer->writeEndElement();
 
 	//filter
 	m_filter->save(writer);
 
 	//columns
 	if (!m_fileLinked) {
 		foreach (Column * col, children<Column>(IncludeHidden))
 			col->save(writer);
 	}
 
 	writer->writeEndElement(); // "liveDataSource"
 }
 
 /*!
   Loads from XML.
 */
 bool LiveDataSource::load(XmlStreamReader* reader, bool preview) {
 	if(!reader->isStartElement() || reader->name() != "liveDataSource") {
 		reader->raiseError(i18n("no liveDataSource element found"));
 		return false;
 	}
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	QString attributeWarning = i18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "LiveDataSource")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader))
 				return false;
 		} else if (reader->name() == "general") {
 			attribs = reader->attributes();
 
 			str = attribs.value("fileName").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'fileName'"));
 			else
 				m_fileName = str;
 
 			str = attribs.value("fileType").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'fileType'"));
 			else
 				m_fileType = (FileType)str.toInt();
 
 			str = attribs.value("fileWatched").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'fileWatched'"));
 			else
 				m_fileWatched = str.toInt();
 
 			str = attribs.value("fileLinked").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'fileLinked'"));
 			else
 				m_fileLinked = str.toInt();
 
 			str = attribs.value("updateType").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'updateType'"));
 			else
 				m_updateType =  static_cast<UpdateType>(str.toInt());
 
 			str = attribs.value("sourceType").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'sourceType'"));
 			else
 				m_sourceType =  static_cast<SourceType>(str.toInt());
 
 			str = attribs.value("readingType").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.arg("'readingType'"));
 			else
 				m_readingType =  static_cast<ReadingType>(str.toInt());
 
 			if (m_updateType == TimeInterval) {
 				str = attribs.value("updateInterval").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'updateInterval'"));
 				else
 					m_updateInterval = str.toInt();
 			}
 
 			if (m_readingType != TillEnd) {
 				str = attribs.value("sampleRate").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'sampleRate'"));
 				else
 					m_sampleRate = str.toInt();
 			}
 
 			switch (m_sourceType) {
 			case SerialPort:
 				str = attribs.value("baudRate").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'baudRate'"));
 				else
 					m_baudRate = str.toInt();
 
 				str = attribs.value("serialPortName").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'serialPortName'"));
 				else
 					m_serialPortName = str;
 
 				break;
 			case NetworkTcpSocket:
 			case NetworkUdpSocket:
 				str = attribs.value("host").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'host'"));
 				else
 					m_host = str;
 
 				str = attribs.value("port").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.arg("'port'"));
 				else
 					m_host = str;
 				break;
 			case FileOrPipe:
 				break;
 			case LocalSocket:
 				break;
 			default:
 				break;
 			}
 
 		} else if (reader->name() == "asciiFilter") {
 			m_filter = new AsciiFilter();
 			if (!m_filter->load(reader))
 				return false;
 		} else if(reader->name() == "column") {
 			Column* column = new Column("", AbstractColumn::Text);
 			if (!column->load(reader, preview)) {
 				delete column;
 				setColumnCount(0);
 				return false;
 			}
 			addChild(column);
 		} else {// unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	//read the content of the file if it was only linked
 	if (m_fileLinked)
 		this->read();
 
 	return !reader->hasError();
 }
diff --git a/src/kdefrontend/datasources/ImportFileDialog.cpp b/src/kdefrontend/datasources/ImportFileDialog.cpp
index 0b66dee96..9cc84374e 100644
--- a/src/kdefrontend/datasources/ImportFileDialog.cpp
+++ b/src/kdefrontend/datasources/ImportFileDialog.cpp
@@ -1,354 +1,401 @@
 /***************************************************************************
     File                 : ImportDialog.cc
     Project              : LabPlot
     Description          : import file data dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2008-2017 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2008-2015 by Stefan Gerlach (stefan.gerlach@uni.kn)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "ImportFileDialog.h"
 #include "ImportFileWidget.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/datasources/filters/AbstractFileFilter.h"
 #include "backend/datasources/filters/HDFFilter.h"
 #include "backend/datasources/filters/NetCDFFilter.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/core/Workbook.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/MainWin.h"
 
 #include <KMessageBox>
 #include <KInputDialog>
 #include <KSharedConfig>
 #include <KWindowConfig>
 #include <KLocalizedString>
 
 #include <QProgressBar>
+#include <QTcpSocket>
+#include <QLocalSocket>
+#include <QUdpSocket>
 #include <QStatusBar>
 #include <QDir>
 #include <QInputDialog>
 #include <QMenu>
 
 /*!
 	\class ImportFileDialog
 	\brief Dialog for importing data from a file. Embeds \c ImportFileWidget and provides the standard buttons.
 
 	\ingroup kdefrontend
  */
 
 ImportFileDialog::ImportFileDialog(MainWin* parent, bool liveDataSource, const QString& fileName) : ImportDialog(parent),
 	m_importFileWidget(new ImportFileWidget(this, fileName)),
 	m_showOptions(false) {
 
 	vLayout->addWidget(m_importFileWidget);
 	setButtons(KDialog::Ok | KDialog::User1 | KDialog::Cancel);
 
 	//hide the data-source related widgets
 	if (!liveDataSource) {
 		setModel();
 		//TODO: disable for file data sources
 		m_importFileWidget->hideDataSource();
 	} else
 		m_importFileWidget->initializeAndFillPortsAndBaudRates();
 
 	connect(this, SIGNAL(user1Clicked()), this, SLOT(toggleOptions()));
 	connect(m_importFileWidget, SIGNAL(checkedFitsTableToMatrix(bool)), this, SLOT(checkOnFitsTableToMatrix(bool)));
 
 	connect(m_importFileWidget, SIGNAL(fileNameChanged()), this, SLOT(checkOkButton()));
 	connect(m_importFileWidget, SIGNAL(sourceTypeChanged()), this, SLOT(checkOkButton()));
 	connect(m_importFileWidget, SIGNAL(hostChanged()), this, SLOT(checkOkButton()));
 	connect(m_importFileWidget, SIGNAL(portChanged()), this, SLOT(checkOkButton()));
 
 	if (!liveDataSource) {
 		setCaption(i18n("Import Data to Spreadsheet or Matrix"));
 		m_importFileWidget->hideDataSource();
 	} else
 		setCaption(i18n("Add new live data source"));
 
 	setWindowIcon(QIcon::fromTheme("document-import-database"));
 
 	QTimer::singleShot(0, this, &ImportFileDialog::loadSettings);
 }
 
 void ImportFileDialog::loadSettings() {
 	//restore saved settings
 	QApplication::processEvents(QEventLoop::AllEvents, 0);
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportFileDialog");
 	m_showOptions = conf.readEntry("ShowOptions", false);
 	m_showOptions ? setButtonText(KDialog::User1, i18n("Hide Options")) : setButtonText(KDialog::User1, i18n("Show Options"));
 	m_importFileWidget->showOptions(m_showOptions);
 
 	KWindowConfig::restoreWindowSize(windowHandle(), conf);
 }
 
 ImportFileDialog::~ImportFileDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportFileDialog");
 	conf.writeEntry("ShowOptions", m_showOptions);
 	if (cbPosition)
 		conf.writeEntry("Position", cbPosition->currentIndex());
 
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 /*!
   triggers data import to the live data source \c source
 */
 void ImportFileDialog::importToLiveDataSource(LiveDataSource* source, QStatusBar* statusBar) const {
 	m_importFileWidget->saveSettings(source);
 
 	//show a progress bar in the status bar
 	QProgressBar* progressBar = new QProgressBar();
 	progressBar->setRange(0, 100);
 	connect(source->filter(), SIGNAL(completed(int)), progressBar, SLOT(setValue(int)));
 
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 	WAIT_CURSOR;
 
 	QTime timer;
 	timer.start();
 	source->read();
 	statusBar->showMessage( i18n("Live data source created in %1 seconds.", (float)timer.elapsed()/1000) );
 
 	RESET_CURSOR;
 	statusBar->removeWidget(progressBar);
 	source->ready();
 }
 /*!
   triggers data import to the currently selected data container
 */
 void ImportFileDialog::importTo(QStatusBar* statusBar) const {
 	DEBUG("ImportFileDialog::importTo()");
 	QDEBUG("cbAddTo->currentModelIndex() =" << cbAddTo->currentModelIndex());
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(cbAddTo->currentModelIndex().internalPointer());
 	if (!aspect) {
 		DEBUG("ERROR in importTo(): No aspect available");
 		DEBUG("cbAddTo->currentModelIndex().isValid() = " << cbAddTo->currentModelIndex().isValid());
 		DEBUG("cbAddTo->currentModelIndex() row/column = " << cbAddTo->currentModelIndex().row() << ' ' << cbAddTo->currentModelIndex().column());
 		return;
 	}
 
 	QString fileName = m_importFileWidget->fileName();
 	AbstractFileFilter* filter = m_importFileWidget->currentFileFilter();
 	AbstractFileFilter::ImportMode mode = AbstractFileFilter::ImportMode(cbPosition->currentIndex());
 
 	//show a progress bar in the status bar
 	QProgressBar* progressBar = new QProgressBar();
 	progressBar->setRange(0, 100);
 	connect(filter, SIGNAL(completed(int)), progressBar, SLOT(setValue(int)));
 
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 
 	WAIT_CURSOR;
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 
 	QTime timer;
 	timer.start();
 	if (aspect->inherits("Matrix")) {
 		Matrix* matrix = qobject_cast<Matrix*>(aspect);
 		filter->readDataFromFile(fileName, matrix, mode);
 	} else if (aspect->inherits("Spreadsheet")) {
 		Spreadsheet* spreadsheet = qobject_cast<Spreadsheet*>(aspect);
 		filter->readDataFromFile(fileName, spreadsheet, mode);
 	} else if (aspect->inherits("Workbook")) {
 		Workbook* workbook = qobject_cast<Workbook*>(aspect);
 		QList<AbstractAspect*> sheets = workbook->children<AbstractAspect>();
 
 		QStringList names;
 		LiveDataSource::FileType fileType = m_importFileWidget->currentFileType();
 		if (fileType == LiveDataSource::HDF)
 			names = m_importFileWidget->selectedHDFNames();
 		else if (fileType == LiveDataSource::NETCDF)
 			names = m_importFileWidget->selectedNetCDFNames();
 
 		//multiple extensions selected
 
 		// multiple data sets/variables for HDF/NetCDF
 		if (fileType == LiveDataSource::HDF || fileType == LiveDataSource::NETCDF) {
 			int nrNames = names.size(), offset = sheets.size();
 
 			int start=0;
 			if (mode == AbstractFileFilter::Replace)
 				start=offset;
 
 			// add additional sheets
 			for (int i = start; i < nrNames; i++) {
 				Spreadsheet *spreadsheet = new Spreadsheet(0, i18n("Spreadsheet"));
 				if (mode == AbstractFileFilter::Prepend)
 					workbook->insertChildBefore(spreadsheet,sheets[0]);
 				else
 					workbook->addChild(spreadsheet);
 			}
 
 			if (mode != AbstractFileFilter::Append)
 				offset = 0;
 
 			// import to sheets
 			sheets = workbook->children<AbstractAspect>();
 			for (int i = 0; i < nrNames; i++) {
 				if (fileType == LiveDataSource::HDF)
 					((HDFFilter*) filter)->setCurrentDataSetName(names[i]);
 				else
 					((NetCDFFilter*) filter)->setCurrentVarName(names[i]);
 
 				if (sheets[i+offset]->inherits("Matrix"))
 					filter->readDataFromFile(fileName, qobject_cast<Matrix*>(sheets[i+offset]));
 				else if (sheets[i+offset]->inherits("Spreadsheet"))
 					filter->readDataFromFile(fileName, qobject_cast<Spreadsheet*>(sheets[i+offset]));
 			}
 		} else { // single import file types
 			// use active spreadsheet/matrix if present, else new spreadsheet
 			Spreadsheet* spreadsheet = workbook->currentSpreadsheet();
 			Matrix* matrix = workbook->currentMatrix();
 			if (spreadsheet)
 				filter->readDataFromFile(fileName, spreadsheet, mode);
 			else if (matrix)
 				filter->readDataFromFile(fileName, matrix, mode);
 			else {
 				spreadsheet = new Spreadsheet(0, i18n("Spreadsheet"));
 				workbook->addChild(spreadsheet);
 				filter->readDataFromFile(fileName, spreadsheet, mode);
 			}
 		}
 	}
 	statusBar->showMessage( i18n("File %1 imported in %2 seconds.", fileName, (float)timer.elapsed()/1000) );
 
 	RESET_CURSOR;
 	statusBar->removeWidget(progressBar);
 	delete filter;
 }
 
 void ImportFileDialog::toggleOptions() {
 	m_importFileWidget->showOptions(!m_showOptions);
 	m_showOptions = !m_showOptions;
 	m_showOptions ? setButtonText(KDialog::User1,i18n("Hide Options")) : setButtonText(KDialog::User1,i18n("Show Options"));
 
 	//resize the dialog
 	mainWidget()->resize(layout()->minimumSize());
 	layout()->activate();
 	resize( QSize(this->width(), 0).expandedTo(minimumSize()) );
 }
 
 void ImportFileDialog::checkOnFitsTableToMatrix(const bool enable) {
 	if (cbAddTo) {
 		QDEBUG("cbAddTo->currentModelIndex() = " << cbAddTo->currentModelIndex());
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbAddTo->currentModelIndex().internalPointer());
 		if (!aspect) {
 			DEBUG("ERROR: no aspect available.");
 			return;
 		}
 
 		if(aspect->inherits("Matrix"))
 			enableButtonOk(enable);
 	}
 }
 
 void ImportFileDialog::checkOkButton() {
 	DEBUG("ImportFileDialog::checkOkButton()");
 	if (cbAddTo) { //only check for the target container when no file data source is being added
 		QDEBUG(" cbAddTo->currentModelIndex() = " << cbAddTo->currentModelIndex());
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbAddTo->currentModelIndex().internalPointer());
 		if (!aspect) {
 			enableButtonOk(false);
 			lPosition->setEnabled(false);
 			cbPosition->setEnabled(false);
 			DEBUG("WARNING: no aspect available.");
 			return;
 		} else {
 			DEBUG("Aspect available.");
 			lPosition->setEnabled(true);
 			cbPosition->setEnabled(true);
 
 			//when doing ASCII import to a matrix, hide the options for using the file header (first line)
 			//to name the columns since the column names are fixed in a matrix
 			const Matrix* matrix = dynamic_cast<const Matrix*>(aspect);
 			m_importFileWidget->showAsciiHeaderOptions(matrix == NULL);
 		}
 	}
 
 	QString fileName = m_importFileWidget->fileName();
-	if (m_importFileWidget->currentFileType() != LiveDataSource::FITS) {
 #ifndef HAVE_WINDOWS
 		if (!fileName.isEmpty() && fileName.left(1) != QDir::separator())
 			fileName = QDir::homePath() + QDir::separator() + fileName;
 #endif
-	} else {	// LiveDataSource::FITS
-		int extensionBraceletPos = -1;
-		if (!fileName.isEmpty()) {
-			if(fileName.right(1) == QLatin1String("]")) {
-				for (int i = fileName.size() - 1; i >= 5; --i) {
-					if (fileName.at(i) == QLatin1Char('[')) {
-						extensionBraceletPos = i;
-						break;
-					}
-				}
-			}
-		}
-#ifndef HAVE_WINDOWS
-		if (fileName.left(1) != QDir::separator())
-			fileName = QDir::homePath() + QDir::separator() + fileName.mid(0, extensionBraceletPos);
-		else
-#endif
-			fileName = fileName.mid(0, extensionBraceletPos);
-	}
+
 	DEBUG(" fileName = " << fileName.toUtf8().constData());
 
 	bool enable = !m_importFileWidget->host().isEmpty() && !m_importFileWidget->port().isEmpty();
 
 	switch (m_importFileWidget->currentSourceType()) {
 	case LiveDataSource::SourceType::FileOrPipe:
 		enableButtonOk( QFile::exists(fileName) );
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
-		enableButtonOk( QFile::exists(fileName) );
+
+        if (QFile::exists(fileName)) {
+            QLocalSocket* socket = new QLocalSocket(this);
+            socket->connectToServer(fileName, QLocalSocket::ReadOnly);
+            bool localSocketConnected = socket->waitForConnected(2000);
+
+            enableButtonOk(localSocketConnected);
+
+            if (socket->state() == QLocalSocket::ConnectedState) {
+                socket->disconnectFromServer();
+                socket->waitForDisconnected(1000);
+                connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));
+            } else {
+                delete socket;
+            }
+
+        } else {
+            enableButtonOk(false);
+        }
+
 		break;
-	case LiveDataSource::SourceType::NetworkTcpSocket:
-		enableButtonOk(enable);
+	case LiveDataSource::SourceType::NetworkTcpSocket:  
+        if (enable) {
+            QTcpSocket* socket = new QTcpSocket(this);
+            socket = new QTcpSocket(this);
+            socket->connectToHost(m_importFileWidget->host(), m_importFileWidget->port().toInt(), QTcpSocket::ReadOnly);
+            bool tcpSocketConnected = socket->waitForConnected(2000);
+
+            enableButtonOk(tcpSocketConnected);
+
+            if (socket->state() == QTcpSocket::ConnectedState) {
+                socket->disconnectFromHost();
+                socket->waitForDisconnected(1000);
+                connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));
+            } else {
+                delete socket;
+            }
+        } else {
+            enableButtonOk(false);
+        }
 		break;
 	case LiveDataSource::SourceType::NetworkUdpSocket:
-		enableButtonOk(enable);
-		break;
+        if (enable) {
+            QUdpSocket* socket = new QUdpSocket(this);
+            socket->connectToHost(m_importFileWidget->host(), m_importFileWidget->port().toInt(), QUdpSocket::ReadOnly);
+            bool udpSocketConnected = socket->waitForConnected(2000);
+
+            enableButtonOk(udpSocketConnected);
+
+            if (socket->state() == QUdpSocket::ConnectedState) {
+                socket->disconnectFromHost();
+                socket->waitForDisconnected(1000);
+                connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));
+            } else {
+                delete socket;
+            }
+        } else {
+            enableButtonOk(false);
+        }
+
+        break;
 	case LiveDataSource::SourceType::SerialPort:
-		enableButtonOk(m_importFileWidget->serialPort() != -1);
+        if (!m_importFileWidget->serialPort().isEmpty()) {
+            QSerialPort* serialPort = new QSerialPort(this);
+
+            serialPort->setBaudRate(m_importFileWidget->baudRate());
+            serialPort->setPortName(m_importFileWidget->serialPort());
+
+            bool serialPortOpened = serialPort->open(QIODevice::ReadOnly);
+            enableButtonOk(serialPortOpened);
+        } else {
+            enableButtonOk(false);
+        }
 		break;
 	default:
 		break;
 	}
 }
 
 QString ImportFileDialog::selectedObject() const {
 	QString path = m_importFileWidget->fileName();
 
 	//determine the file name only
 	QString name = path.right( path.length()-path.lastIndexOf(QDir::separator())-1 );
 
 	//strip away the extension if available
 	if (name.indexOf('.') != -1)
 		name = name.left(name.lastIndexOf('.'));
 	return name;
 }
diff --git a/src/kdefrontend/datasources/ImportFileWidget.cpp b/src/kdefrontend/datasources/ImportFileWidget.cpp
index f408c7241..ad1cddb8b 100644
--- a/src/kdefrontend/datasources/ImportFileWidget.cpp
+++ b/src/kdefrontend/datasources/ImportFileWidget.cpp
@@ -1,969 +1,973 @@
 /***************************************************************************
 File                 : ImportFileWidget.cpp
 Project              : LabPlot
 Description          : import file data widget
 --------------------------------------------------------------------
 Copyright            : (C) 2009-2017 Stefan Gerlach (stefan.gerlach@uni.kn)
 Copyright            : (C) 2009-2017 Alexander Semke (alexander.semke@web.de)
 Copyright            : (C) 2017 Fabian Kristof (fkristofszabolcs@gmail.com)
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "ImportFileWidget.h"
 #include "FileInfoDialog.h"
 #include "backend/datasources/filters/AsciiFilter.h"
 #include "backend/datasources/filters/BinaryFilter.h"
 #include "backend/datasources/filters/HDFFilter.h"
 #include "backend/datasources/filters/NetCDFFilter.h"
 #include "backend/datasources/filters/ImageFilter.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "AsciiOptionsWidget.h"
 #include "BinaryOptionsWidget.h"
 #include "HDFOptionsWidget.h"
 #include "ImageOptionsWidget.h"
 #include "NetCDFOptionsWidget.h"
 #include "FITSOptionsWidget.h"
 
 #include <QTableWidget>
 #include <QInputDialog>
 #include <QDir>
 #include <QFileDialog>
 #include <QProcess>
 #include <QIntValidator>
 #include <KUrlCompletion>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <QTimer>
 #include <QStandardItemModel>
 #include <QImageReader>
 #include <KUrlCompletion>
 
 /*!
    \class ImportFileWidget
    \brief Widget for importing data from a file.
 
    \ingroup kdefrontend
 */
 ImportFileWidget::ImportFileWidget(QWidget* parent, const QString& fileName) : QWidget(parent), m_fileName(fileName),
 	m_liveDataSource(true) {
 	ui.setupUi(this);
 
 	KUrlCompletion *comp = new KUrlCompletion();
 	ui.kleFileName->setCompletionObject(comp);
 
 	ui.cbFileType->addItems(LiveDataSource::fileTypes());
 	QStringList filterItems;
 	filterItems << i18n("Automatic") << i18n("Custom");
 	ui.cbFilter->addItems(filterItems);
 
 	// file type specific option widgets
 	QWidget* asciiw = new QWidget();
 	m_asciiOptionsWidget = std::unique_ptr<AsciiOptionsWidget>(new AsciiOptionsWidget(asciiw));
 	ui.swOptions->insertWidget(LiveDataSource::Ascii, asciiw);
 
 	QWidget* binaryw = new QWidget();
 	m_binaryOptionsWidget = std::unique_ptr<BinaryOptionsWidget>(new BinaryOptionsWidget(binaryw));
 	ui.swOptions->insertWidget(LiveDataSource::Binary, binaryw);
 
 	QWidget* imagew = new QWidget();
 	m_imageOptionsWidget = std::unique_ptr<ImageOptionsWidget>(new ImageOptionsWidget(imagew));
 	ui.swOptions->insertWidget(LiveDataSource::Image, imagew);
 
 	QWidget* hdfw = new QWidget();
 	m_hdfOptionsWidget = std::unique_ptr<HDFOptionsWidget>(new HDFOptionsWidget(hdfw, this));
 	ui.swOptions->insertWidget(LiveDataSource::HDF, hdfw);
 
 	QWidget* netcdfw = new QWidget();
 	m_netcdfOptionsWidget = std::unique_ptr<NetCDFOptionsWidget>(new NetCDFOptionsWidget(netcdfw, this));
 	ui.swOptions->insertWidget(LiveDataSource::NETCDF, netcdfw);
 
 	QWidget* fitsw = new QWidget();
 	m_fitsOptionsWidget = std::unique_ptr<FITSOptionsWidget>(new FITSOptionsWidget(fitsw, this));
 	ui.swOptions->insertWidget(LiveDataSource::FITS, fitsw);
 
 	// the table widget for preview
 	m_twPreview = new QTableWidget(ui.tePreview);
 	m_twPreview->verticalHeader()->hide();
 	m_twPreview->setEditTriggers(QTableWidget::NoEditTriggers);
 	QHBoxLayout* layout = new QHBoxLayout;
 	layout->addWidget(m_twPreview);
 	ui.tePreview->setLayout(layout);
 	m_twPreview->hide();
 
 	// default filter
 	ui.swOptions->setCurrentIndex(LiveDataSource::Ascii);
 #if !defined(HAVE_HDF5) || !defined(HAVE_NETCDF) || !defined(HAVE_FITS)
 	const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(ui.cbFileType->model());
 #endif
 #ifndef HAVE_HDF5
 	// disable HDF5 item
 	QStandardItem* item = model->item(LiveDataSource::HDF);
 	item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 #endif
 #ifndef HAVE_NETCDF
 	// disable NETCDF item
 	QStandardItem* item2 = model->item(LiveDataSource::NETCDF);
 	item2->setFlags(item2->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 #endif
 #ifndef HAVE_FITS
 	// disable FITS item
 	QStandardItem* item3 = model->item(LiveDataSource::FITS);
 	item3->setFlags(item3->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 #endif
 
 	ui.lePort->setValidator( new QIntValidator(ui.lePort) );
 	ui.gbOptions->hide();
 	ui.gbUpdateOptions->hide();
 
 	ui.bOpen->setIcon( QIcon::fromTheme("document-open") );
 	ui.bFileInfo->setIcon( QIcon::fromTheme("help-about") );
 	ui.bManageFilters->setIcon( QIcon::fromTheme("configure") );
 	ui.bSaveFilter->setIcon( QIcon::fromTheme("document-save") );
 	ui.bRefreshPreview->setIcon( QIcon::fromTheme("view-refresh") );
 
 	connect( ui.kleFileName, SIGNAL(textChanged(QString)), SLOT(fileNameChanged(QString)) );
 	connect( ui.bOpen, SIGNAL(clicked()), this, SLOT (selectFile()) );
 	connect( ui.bFileInfo, SIGNAL(clicked()), this, SLOT (fileInfoDialog()) );
 	connect( ui.bSaveFilter, SIGNAL(clicked()), this, SLOT (saveFilter()) );
 	connect( ui.bManageFilters, SIGNAL(clicked()), this, SLOT (manageFilters()) );
 	connect( ui.cbFileType, SIGNAL(currentIndexChanged(int)), SLOT(fileTypeChanged(int)) );
 	connect( ui.cbUpdateType, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTypeChanged(int)));
 	connect( ui.cbReadType, SIGNAL(currentIndexChanged(int)), this, SLOT(readingTypeChanged(int)));
 	connect( ui.cbFilter, SIGNAL(activated(int)), SLOT(filterChanged(int)) );
 	connect( ui.bRefreshPreview, SIGNAL(clicked()), SLOT(refreshPreview()) );
 
 	connect(ui.leHost, SIGNAL(textChanged(QString)), this, SIGNAL(hostChanged()));
 	connect(ui.lePort, SIGNAL(textChanged(QString)), this, SIGNAL(portChanged()));
 
 	connect( ui.cbSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(sourceTypeChanged(int)));
 
 	//TODO: implement save/load of user-defined settings later and activate these buttons again
 	ui.bSaveFilter->hide();
 	ui.bManageFilters->hide();
 
 	//defer the loading of settings a bit in order to show the dialog prior to blocking the GUI in refreshPreview()
 	QTimer::singleShot( 100, this, SLOT(loadSettings()) );
 }
 
 void ImportFileWidget::loadSettings() {
 	//load last used settings
 	QString confName;
 	if (m_liveDataSource)
 		confName = QLatin1String("LiveDataImport");
 	else
 		confName = QLatin1String("FileImport");
 	KConfigGroup conf(KSharedConfig::openConfig(), confName);
 
 	//settings for data type specific widgets
 	m_asciiOptionsWidget->loadSettings();
 	m_binaryOptionsWidget->loadSettings();
 	m_imageOptionsWidget->loadSettings();
 
 	//read the source type first since settings in fileNameChanged() depend on this
 	ui.cbSourceType->setCurrentIndex(conf.readEntry("SourceType").toInt());
 
 	//general settings
 	ui.cbFileType->setCurrentIndex(conf.readEntry("Type", 0));
 	ui.cbFilter->setCurrentIndex(conf.readEntry("Filter", 0));
 	filterChanged(ui.cbFilter->currentIndex());	// needed if filter is not changed
 	if (m_fileName.isEmpty())
 		ui.kleFileName->setText(conf.readEntry("LastImportedFile", ""));
 	else
 		ui.kleFileName->setText(m_fileName);
 
 	//live data related settings
 	ui.cbBaudRate->setCurrentIndex(conf.readEntry("BaudRate").toInt());
 	ui.cbReadType->setCurrentIndex(conf.readEntry("ReadType").toInt());
 	ui.cbSerialPort->setCurrentIndex(conf.readEntry("SerialPort").toInt());
 	ui.cbUpdateType->setCurrentIndex(conf.readEntry("UpdateType").toInt());
 	ui.leHost->setText(conf.readEntry("Host",""));
 	ui.leKeepLastValues->setText(conf.readEntry("KeepLastNValues",""));
 	ui.lePort->setText(conf.readEntry("Port",""));
 	ui.sbSampleRate->setValue(conf.readEntry("SampleRate").toInt());
 	ui.sbUpdateInterval->setValue(conf.readEntry("UpdateInterval").toInt());
 }
 
 ImportFileWidget::~ImportFileWidget() {
 	// save current settings
 	QString confName;
 	if (m_liveDataSource)
 		confName = QLatin1String("LiveDataImport");
 	else
 		confName = QLatin1String("FileImport");
 	KConfigGroup conf(KSharedConfig::openConfig(), confName);
 
 	// general settings
 	conf.writeEntry("Type", ui.cbFileType->currentIndex());
 	conf.writeEntry("Filter", ui.cbFilter->currentIndex());
 	conf.writeEntry("LastImportedFile", ui.kleFileName->text());
 
 	//live data related settings
 	conf.writeEntry("SourceType", ui.cbSourceType->currentIndex());
 	conf.writeEntry("UpdateType", ui.cbUpdateType->currentIndex());
 	conf.writeEntry("ReadType", ui.cbReadType->currentIndex());
 	conf.writeEntry("SampleRate", ui.sbSampleRate->value());
 	conf.writeEntry("KeepLastNValues", ui.leKeepLastValues->text());
 	conf.writeEntry("BaudRate", ui.cbBaudRate->currentIndex());
 	conf.writeEntry("SerialPort", ui.cbSerialPort->currentIndex());
 	conf.writeEntry("Host", ui.leHost->text());
 	conf.writeEntry("Port", ui.lePort->text());
 	conf.writeEntry("UpdateInterval", ui.sbUpdateInterval->value());
 
 	// data type specific settings
 	m_asciiOptionsWidget->saveSettings();
 	m_binaryOptionsWidget->saveSettings();
 	m_imageOptionsWidget->saveSettings();
 }
 
 void ImportFileWidget::hideDataSource() {
 	m_liveDataSource = false;
 	ui.gbUpdateOptions->hide();
 
 	ui.chbLinkFile->hide();
 
 	ui.cbBaudRate->hide();
 	ui.lBaudRate->hide();
 
 	ui.lHost->hide();
 	ui.leHost->hide();
 
 	ui.lPort->hide();
 	ui.lePort->hide();
 
 	ui.cbSerialPort->hide();
 	ui.lSerialPort->hide();
 
 	ui.lSourceType->hide();
 	ui.cbSourceType->hide();
 
 	ui.cbUpdateType->hide();
 	ui.lUpdateType->hide();
 
 	ui.sbUpdateInterval->hide();
 	ui.lUpdateInterval->hide();
 }
 
 void ImportFileWidget::showAsciiHeaderOptions(bool b) {
 	m_asciiOptionsWidget->showAsciiHeaderOptions(b);
 }
 
 void ImportFileWidget::showOptions(bool b) {
 	ui.gbOptions->setVisible(b);
 
 	if (m_liveDataSource)
 		ui.gbUpdateOptions->setVisible(b);
 
 	resize(layout()->minimumSize());
 }
 
 QString ImportFileWidget::fileName() const {
 	if (currentFileType() == LiveDataSource::FITS) {
 		QString extensionName = m_fitsOptionsWidget->currentExtensionName();
 		if (!extensionName.isEmpty())
 			return ui.kleFileName->text() + QLatin1String("[") + extensionName + QLatin1String("]");
 	}
 
 	return ui.kleFileName->text();
 }
 
 QString ImportFileWidget::host() const {
 	return ui.leHost->text();
 }
 
 QString ImportFileWidget::port() const {
 	return ui.lePort->text();
 }
 
-int ImportFileWidget::serialPort() const {
-	return ui.cbSerialPort->currentIndex();
+QString ImportFileWidget::serialPort() const {
+    return ui.cbSerialPort->currentText();
+}
+
+int ImportFileWidget::baudRate() const {
+    return ui.cbBaudRate->currentText().toInt();
 }
 
 /*!
 	saves the settings to the data source \c source.
 */
 void ImportFileWidget::saveSettings(LiveDataSource* source) const {
 	LiveDataSource::FileType fileType = static_cast<LiveDataSource::FileType>(ui.cbFileType->currentIndex());
 	LiveDataSource::UpdateType updateType = static_cast<LiveDataSource::UpdateType>(ui.cbUpdateType->currentIndex());
 	LiveDataSource::SourceType sourceType = static_cast<LiveDataSource::SourceType>(ui.cbSourceType->currentIndex());
 	LiveDataSource::ReadingType readingType = static_cast<LiveDataSource::ReadingType>(ui.cbReadType->currentIndex());
 
 	source->setComment( ui.kleFileName->text() );
 	source->setFileType(fileType);
 	source->setFilter(this->currentFileFilter());
 
 	source->setSourceType(sourceType);
 	source->setReadingType(readingType);
 
 	if (updateType == LiveDataSource::UpdateType::TimeInterval)
 		source->setUpdateInterval(ui.sbUpdateInterval->value());
 	else
 		source->setFileWatched(true);
 
 	if (!ui.leKeepLastValues->text().isEmpty()) {
 		source->setKeepLastValues(true);
 		source->setKeepNvalues(ui.leKeepLastValues->text().toInt());
 	}
 
 	source->setUpdateType(updateType);
 
 	if (readingType != LiveDataSource::ReadingType::TillEnd)
 		source->setSampleRate(ui.sbSampleRate->value());
 
 	switch (sourceType) {
 	case LiveDataSource::SourceType::FileOrPipe:
 		source->setFileName( ui.kleFileName->text() );
 		source->setFileLinked( ui.chbLinkFile->isChecked() );
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
 		source->setLocalSocketName(ui.kleFileName->text());
 		break;
 	case LiveDataSource::SourceType::NetworkTcpSocket:
 	case LiveDataSource::SourceType::NetworkUdpSocket:
 		source->setHost(ui.leHost->text());
 		source->setPort(ui.lePort->text().toInt());
 		break;
 	case LiveDataSource::SourceType::SerialPort:
 		source->setBaudRate(ui.cbBaudRate->currentText().toInt());
 		source->setSerialPort(ui.cbSerialPort->currentText());
 		break;
 	default:
 		break;
 	}
 }
 
 /*!
 	returns the currently used file type.
 */
 LiveDataSource::FileType ImportFileWidget::currentFileType() const {
 	return static_cast<LiveDataSource::FileType>(ui.cbFileType->currentIndex());
 }
 
 LiveDataSource::SourceType ImportFileWidget::currentSourceType() const {
 	return static_cast<LiveDataSource::SourceType>(ui.cbSourceType->currentIndex());
 }
 
 /*!
 	returns the currently used filter.
 */
 AbstractFileFilter* ImportFileWidget::currentFileFilter() const {
 	DEBUG("currentFileFilter()");
 	LiveDataSource::FileType fileType = static_cast<LiveDataSource::FileType>(ui.cbFileType->currentIndex());
 
 	switch (fileType) {
 	case LiveDataSource::Ascii: {
 //TODO			std::unique_ptr<AsciiFilter> filter(new AsciiFilter());
 			AsciiFilter* filter = new AsciiFilter();
 
 			if (ui.cbFilter->currentIndex() == 0)     //"automatic"
 				filter->setAutoModeEnabled(true);
 			else if (ui.cbFilter->currentIndex() == 1) { //"custom"
 				filter->setAutoModeEnabled(false);
 				m_asciiOptionsWidget->applyFilterSettings(filter);
 			} else
 				filter->loadFilterSettings( ui.cbFilter->currentText() );
 
 			//save the data portion to import
 			filter->setStartRow( ui.sbStartRow->value());
 			filter->setEndRow( ui.sbEndRow->value() );
 			filter->setStartColumn( ui.sbStartColumn->value());
 			filter->setEndColumn( ui.sbEndColumn->value());
 
 			return filter;
 		}
 	case LiveDataSource::Binary: {
 			BinaryFilter* filter = new BinaryFilter();
 			if ( ui.cbFilter->currentIndex() == 0 ) 	//"automatic"
 				filter->setAutoModeEnabled(true);
 			else if ( ui.cbFilter->currentIndex() == 1 ) {	//"custom"
 				filter->setAutoModeEnabled(false);
 				m_binaryOptionsWidget->applyFilterSettings(filter);
 			} else {
 				//TODO: load filter settings
 // 			filter->setFilterName( ui.cbFilter->currentText() );
 			}
 
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 
 			return filter;
 		}
 	case LiveDataSource::Image: {
 			ImageFilter* filter = new ImageFilter();
 
 			filter->setImportFormat(m_imageOptionsWidget->currentFormat());
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 			filter->setStartColumn( ui.sbStartColumn->value() );
 			filter->setEndColumn( ui.sbEndColumn->value() );
 
 			return filter;
 		}
 	case LiveDataSource::HDF: {
 			HDFFilter* filter = new HDFFilter();
 			QStringList names = selectedHDFNames();
 			if (!names.isEmpty())
 				filter->setCurrentDataSetName(names[0]);
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 			filter->setStartColumn( ui.sbStartColumn->value() );
 			filter->setEndColumn( ui.sbEndColumn->value() );
 
 			return filter;
 		}
 	case LiveDataSource::NETCDF: {
 			NetCDFFilter* filter = new NetCDFFilter();
 
 			if (!selectedNetCDFNames().isEmpty())
 				filter->setCurrentVarName(selectedNetCDFNames()[0]);
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 			filter->setStartColumn( ui.sbStartColumn->value() );
 			filter->setEndColumn( ui.sbEndColumn->value() );
 
 			return filter;
 		}
 	case LiveDataSource::FITS: {
 			FITSFilter* filter = new FITSFilter();
 			filter->setStartRow( ui.sbStartRow->value());
 			filter->setEndRow( ui.sbEndRow->value() );
 			filter->setStartColumn( ui.sbStartColumn->value());
 			filter->setEndColumn( ui.sbEndColumn->value());
 			return filter;
 		}
 	}
 
 	return 0;
 }
 
 /*!
 	opens a file dialog and lets the user select the file data source.
 */
 void ImportFileWidget::selectFile() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportFileWidget");
 	QString dir = conf.readEntry("LastDir", "");
 	QString path = QFileDialog::getOpenFileName(this, i18n("Select the File Data Source"), dir);
 	if (path.isEmpty())
 		return; //cancel was clicked in the file-dialog
 
 	int pos = path.lastIndexOf(QDir::separator());
 	if (pos != -1) {
 		QString newDir = path.left(pos);
 		if (newDir != dir)
 			conf.writeEntry("LastDir", newDir);
 	}
 
 	ui.kleFileName->setText(path);
 
 	//TODO: decide whether the selection of several files should be possible
 // 	QStringList filelist = QFileDialog::getOpenFileNames(this,i18n("Select one or more files to open"));
 // 	if (! filelist.isEmpty() )
 // 		ui.kleFileName->setText(filelist.join(";"));
 }
 
 /************** SLOTS **************************************************************/
 
 /*!
 	called on file name changes.
 	Determines the file format (ASCII, binary etc.), if the file exists,
 	and activates the corresponding options.
 */
 void ImportFileWidget::fileNameChanged(const QString& name) {
 	QString fileName = name;
 #ifndef HAVE_WINDOWS
 	// make relative path
 	if ( !fileName.isEmpty() && fileName.left(1) != QDir::separator())
 		fileName = QDir::homePath() + QDir::separator() + fileName;
 #endif
 
 	bool fileExists = QFile::exists(fileName);
 	if (fileExists)
 		ui.kleFileName->setStyleSheet("");
 	else
 		ui.kleFileName->setStyleSheet("QLineEdit{background:red;}");
 
 	ui.gbOptions->setEnabled(fileExists);
 	ui.bFileInfo->setEnabled(fileExists);
 	ui.cbFileType->setEnabled(fileExists);
 	ui.cbFilter->setEnabled(fileExists);
 	ui.bManageFilters->setEnabled(fileExists);
 	ui.chbLinkFile->setEnabled(fileExists);
 	if (!fileExists) {
 		//file doesn't exist -> delete the content preview that is still potentially
 		//available from the previously selected file
 		ui.tePreview->clear();
 		m_twPreview->clear();
 		m_hdfOptionsWidget->clear();
 		m_netcdfOptionsWidget->clear();
 		m_fitsOptionsWidget->clear();
 
 		emit fileNameChanged();
 		return;
 	}
 
 	if (currentSourceType() == LiveDataSource::FileOrPipe) {
 		QString fileInfo;
 #ifndef HAVE_WINDOWS
 		//check, if we can guess the file type by content
 		QProcess* proc = new QProcess(this);
 		QStringList args;
 		args << "-b" << ui.kleFileName->text();
 		proc->start("file", args);
 		if (proc->waitForReadyRead(1000) == false) {
 			QDEBUG("ERROR: reading file type of file" << fileName);
 			return;
 		}
 		fileInfo = proc->readLine();
 #endif
 
 		QByteArray imageFormat = QImageReader::imageFormat(fileName);
 		if (fileInfo.contains(QLatin1String("compressed data")) || fileInfo.contains(QLatin1String("ASCII")) ||
 				fileName.endsWith(QLatin1String("dat"), Qt::CaseInsensitive) || fileName.endsWith(QLatin1String("txt"), Qt::CaseInsensitive)) {
 			//probably ascii data
 			ui.cbFileType->setCurrentIndex(LiveDataSource::Ascii);
 		} else if (fileInfo.contains(QLatin1String("Hierarchical Data Format")) || fileName.endsWith(QLatin1String("h5"), Qt::CaseInsensitive) ||
 				fileName.endsWith(QLatin1String("hdf"), Qt::CaseInsensitive) || fileName.endsWith(QLatin1String("hdf5"), Qt::CaseInsensitive) ) {
 			ui.cbFileType->setCurrentIndex(LiveDataSource::HDF);
 
 			// update HDF tree widget using current selected file
 			m_hdfOptionsWidget->updateContent((HDFFilter*)this->currentFileFilter(), fileName);
 		} else if (fileInfo.contains(QLatin1String("NetCDF Data Format")) || fileName.endsWith(QLatin1String("nc"), Qt::CaseInsensitive) ||
 				fileName.endsWith(QLatin1String("netcdf"), Qt::CaseInsensitive) || fileName.endsWith(QLatin1String("cdf"), Qt::CaseInsensitive)) {
 			ui.cbFileType->setCurrentIndex(LiveDataSource::NETCDF);
 
 			// update NetCDF tree widget using current selected file
 			m_netcdfOptionsWidget->updateContent((NetCDFFilter*)this->currentFileFilter(), fileName);
 		} else if (fileInfo.contains(QLatin1String("FITS image data")) || fileName.endsWith(QLatin1String("fits"), Qt::CaseInsensitive) ||
 				fileName.endsWith(QLatin1String("fit"), Qt::CaseInsensitive) || fileName.endsWith(QLatin1String("fts"), Qt::CaseInsensitive)) {
 #ifdef HAVE_FITS
 			ui.cbFileType->setCurrentIndex(LiveDataSource::FITS);
 #endif
 
 			// update FITS tree widget using current selected file
 			m_fitsOptionsWidget->updateContent((FITSFilter*)this->currentFileFilter(), fileName);
 		} else if (fileInfo.contains("image") || fileInfo.contains("bitmap") || !imageFormat.isEmpty())
 			ui.cbFileType->setCurrentIndex(LiveDataSource::Image);
 		else
 			ui.cbFileType->setCurrentIndex(LiveDataSource::Binary);
 	}
 
 	refreshPreview();
 	emit fileNameChanged();
 }
 
 /*!
   saves the current filter settings
 */
 void ImportFileWidget::saveFilter() {
 	bool ok;
 	QString text = QInputDialog::getText(this, i18n("Save Filter Settings as"),
 	                                     i18n("Filter name:"), QLineEdit::Normal, i18n("new filter"), &ok);
 	if (ok && !text.isEmpty()) {
 		//TODO
 		//AsciiFilter::saveFilter()
 	}
 }
 
 /*!
   opens a dialog for managing all available predefined filters.
 */
 void ImportFileWidget::manageFilters() {
 	//TODO
 }
 
 /*!
 	Depending on the selected file type, activates the corresponding options in the data portion tab
 	and populates the combobox with the available pre-defined fllter settings for the selected type.
 */
 void ImportFileWidget::fileTypeChanged(int fileType) {
 	ui.swOptions->setCurrentIndex(fileType);
 
 	//default
 	ui.lFilter->show();
 	ui.cbFilter->show();
 
 	//if we switch from netCDF-format (only two tabs available), add the data preview-tab again
 	if (ui.tabWidget->count() == 2) {
 		ui.tabWidget->setTabText(0, i18n("Data format"));
 		ui.tabWidget->insertTab(1, ui.tabDataPreview, i18n("Preview"));
 	}
 	ui.lPreviewLines->show();
 	ui.sbPreviewLines->show();
 	ui.lStartColumn->show();
 	ui.sbStartColumn->show();
 	ui.lEndColumn->show();
 	ui.sbEndColumn->show();
 
 	switch (fileType) {
 	case LiveDataSource::Ascii:
 		break;
 	case LiveDataSource::Binary:
 		ui.lStartColumn->hide();
 		ui.sbStartColumn->hide();
 		ui.lEndColumn->hide();
 		ui.sbEndColumn->hide();
 		break;
 	case LiveDataSource::HDF:
 	case LiveDataSource::NETCDF:
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		// hide global preview tab. we have our own
 		ui.tabWidget->setTabText(0, i18n("Data format && preview"));
 		ui.tabWidget->removeTab(1);
 		ui.tabWidget->setCurrentIndex(0);
 		break;
 	case LiveDataSource::Image:
 		ui.lPreviewLines->hide();
 		ui.sbPreviewLines->hide();
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		break;
 	case LiveDataSource::FITS:
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		ui.tabWidget->setTabText(0, i18n("Data format && preview"));
 		ui.tabWidget->removeTab(1);
 		ui.tabWidget->setCurrentIndex(0);
 		break;
 	default:
 		DEBUG("unknown file type");
 	}
 
 	m_hdfOptionsWidget->clear();
 	m_netcdfOptionsWidget->clear();
 
 	int lastUsedFilterIndex = ui.cbFilter->currentIndex();
 	ui.cbFilter->clear();
 	ui.cbFilter->addItem( i18n("Automatic") );
 	ui.cbFilter->addItem( i18n("Custom") );
 
 	//TODO: populate the combobox with the available pre-defined filter settings for the selected type
 	ui.cbFilter->setCurrentIndex(lastUsedFilterIndex);
 	filterChanged(lastUsedFilterIndex);
 
 	refreshPreview();
 }
 
 
 const QStringList ImportFileWidget::selectedHDFNames() const {
 	return m_hdfOptionsWidget->selectedHDFNames();
 }
 
 const QStringList ImportFileWidget::selectedNetCDFNames() const {
 	return m_netcdfOptionsWidget->selectedNetCDFNames();
 }
 
 const QStringList ImportFileWidget::selectedFITSExtensions() const {
 	return m_fitsOptionsWidget->selectedFITSExtensions();
 }
 
 /*!
 	shows the dialog with the information about the file(s) to be imported.
 */
 void ImportFileWidget::fileInfoDialog() {
 	QStringList files = ui.kleFileName->text().split(';');
 	FileInfoDialog* dlg = new FileInfoDialog(this);
 	dlg->setFiles(files);
 	dlg->exec();
 }
 
 /*!
 	enables the options if the filter "custom" was chosen. Disables the options otherwise.
 */
 void ImportFileWidget::filterChanged(int index) {
 	// ignore filter for these formats
 	if (ui.cbFileType->currentIndex() == LiveDataSource::HDF || ui.cbFileType->currentIndex() == LiveDataSource::NETCDF
 	        || ui.cbFileType->currentIndex() == LiveDataSource::Image || ui.cbFileType->currentIndex() == LiveDataSource::FITS) {
 		ui.swOptions->setEnabled(true);
 		return;
 	}
 
 	if (index == 0) { // "automatic"
 		ui.swOptions->setEnabled(false);
 		ui.bSaveFilter->setEnabled(false);
 	} else if (index == 1) { //custom
 		ui.swOptions->setEnabled(true);
 		ui.bSaveFilter->setEnabled(true);
 	} else {
 		// predefined filter settings were selected.
 		//load and show them in the GUI.
 		//TODO
 	}
 }
 
 void ImportFileWidget::refreshPreview() {
 	DEBUG("refreshPreview()");
 	WAIT_CURSOR;
 
 	QString fileName = ui.kleFileName->text();
 #ifndef HAVE_WINDOWS
 	if (fileName.left(1) != QDir::separator())
 		fileName = QDir::homePath() + QDir::separator() + fileName;
 #endif
 
 	QVector<QStringList> importedStrings;
 	LiveDataSource::FileType fileType = (LiveDataSource::FileType)ui.cbFileType->currentIndex();
 
 	// generic table widget
 	if (fileType == LiveDataSource::Ascii || fileType == LiveDataSource::Binary)
 		m_twPreview->show();
 	else
 		m_twPreview->hide();
 
 	int lines = ui.sbPreviewLines->value();
 
 	bool ok = true;
 	QTableWidget *tmpTableWidget = nullptr;
 	QStringList vectorNameList;
 	QVector<AbstractColumn::ColumnMode> columnModes;
 	switch (fileType) {
 	case LiveDataSource::Ascii: {
 			ui.tePreview->clear();
 
 			AsciiFilter *filter = (AsciiFilter *)this->currentFileFilter();
 			importedStrings = filter->preview(fileName, lines);
 			tmpTableWidget = m_twPreview;
 			vectorNameList = filter->vectorNames();
 			columnModes = filter->columnModes();
 			break;
 		}
 	case LiveDataSource::Binary: {
 			ui.tePreview->clear();
 			BinaryFilter *filter = (BinaryFilter *)this->currentFileFilter();
 			importedStrings = filter->readDataFromFile(fileName, nullptr, AbstractFileFilter::Replace, lines);
 			tmpTableWidget = m_twPreview;
 			break;
 		}
 	case LiveDataSource::Image: {
 			ui.tePreview->clear();
 
 			QImage image(fileName);
 			QTextCursor cursor = ui.tePreview->textCursor();
 			cursor.insertImage(image);
 			RESET_CURSOR;
 			return;
 		}
 	case LiveDataSource::HDF: {
 			HDFFilter *filter = (HDFFilter *)this->currentFileFilter();
 			lines = m_hdfOptionsWidget->lines();
 			importedStrings = filter->readCurrentDataSet(fileName, NULL, ok, AbstractFileFilter::Replace, lines);
 			tmpTableWidget = m_hdfOptionsWidget->previewWidget();
 			break;
 		}
 	case LiveDataSource::NETCDF: {
 			NetCDFFilter *filter = (NetCDFFilter *)this->currentFileFilter();
 			lines = m_netcdfOptionsWidget->lines();
 			importedStrings = filter->readCurrentVar(fileName, NULL, AbstractFileFilter::Replace, lines);
 			tmpTableWidget = m_netcdfOptionsWidget->previewWidget();
 			break;
 		}
 	case LiveDataSource::FITS: {
 			FITSFilter* filter = (FITSFilter*)this->currentFileFilter();
 			lines = m_fitsOptionsWidget->lines();
 
 			QString extensionName = m_fitsOptionsWidget->extensionName(&ok);
 			if (!extensionName.isEmpty())
 				fileName = extensionName;
 
 			bool readFitsTableToMatrix;
 			importedStrings = filter->readChdu(fileName, &readFitsTableToMatrix, lines);
 			emit checkedFitsTableToMatrix(readFitsTableToMatrix);
 
 			tmpTableWidget = m_fitsOptionsWidget->previewWidget();
 			break;
 		}
 	}
 
 	// fill the table widget
 	tmpTableWidget->setRowCount(0);
 	tmpTableWidget->setColumnCount(0);
 	if( !importedStrings.isEmpty() ) {
 		QDEBUG("importedStrings =" << importedStrings);
 		if (!ok) {
 			// show imported strings as error message
 			tmpTableWidget->setRowCount(1);
 			tmpTableWidget->setColumnCount(1);
 			QTableWidgetItem* item = new QTableWidgetItem();
 			item->setText(importedStrings[0][0]);
 			tmpTableWidget->setItem(0, 0, item);
 		} else {
 			//TODO: maxrows not used
 			const int rows = qMax(importedStrings.size(), 1);
 			const int maxColumns = 300;
 			tmpTableWidget->setRowCount(rows);
 
 			for (int i = 0; i < rows; i++) {
 				QDEBUG(importedStrings[i]);
 
 				int cols = importedStrings[i].size() > maxColumns ? maxColumns : importedStrings[i].size();	// new
 				if (cols > tmpTableWidget->columnCount())
 					tmpTableWidget->setColumnCount(cols);
 
 				for (int j = 0; j < cols; j++) {
 					QTableWidgetItem* item = new QTableWidgetItem(importedStrings[i][j]);
 					tmpTableWidget->setItem(i, j, item);
 				}
 			}
 
 			// set header if columnMode available
 			for (int i = 0; i < qMin(tmpTableWidget->columnCount(), columnModes.size()); i++) {
 				QString columnName = QString::number(i+1);
 				if (i < vectorNameList.size())
 					columnName = vectorNameList[i];
 				auto* item = new QTableWidgetItem(columnName + QLatin1String(" {") + ENUM_TO_STRING(AbstractColumn, ColumnMode, columnModes[i]) + QLatin1String("}"));
 				item->setTextAlignment(Qt::AlignLeft);
 				item->setIcon(AbstractColumn::iconForMode(columnModes[i]));
 
 				tmpTableWidget->setHorizontalHeaderItem(i, item);
 			}
 		}
 
 		tmpTableWidget->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 	}
 	RESET_CURSOR;
 }
 
 void ImportFileWidget::updateTypeChanged(int idx) {
 	LiveDataSource::UpdateType type = static_cast<LiveDataSource::UpdateType>(idx);
 
 	if (type == LiveDataSource::UpdateType::TimeInterval) {
 		ui.lUpdateInterval->show();
 		ui.sbUpdateInterval->show();
 		ui.lUpdateIntervalUnit->show();
 	} else if (type == LiveDataSource::UpdateType::NewData) {
 		ui.lUpdateInterval->hide();
 		ui.sbUpdateInterval->hide();
 		ui.lUpdateIntervalUnit->hide();
 	}
 }
 
 void ImportFileWidget::readingTypeChanged(int idx) {
 	LiveDataSource::ReadingType type = static_cast<LiveDataSource::ReadingType>(idx);
 
 	if (type == LiveDataSource::ReadingType::TillEnd) {
 		ui.lSampleRate->hide();
 		ui.sbSampleRate->hide();
 	} else {
 		ui.lSampleRate->show();
 		ui.sbSampleRate->show();
 	}
 }
 
 void ImportFileWidget::sourceTypeChanged(int idx) {
 	LiveDataSource::SourceType type = static_cast<LiveDataSource::SourceType>(idx);
 
 	switch (type) {
 	case LiveDataSource::SourceType::FileOrPipe:
 		ui.lFileName->show();
 		ui.kleFileName->show();
 		ui.bFileInfo->show();
 		ui.bOpen->show();
 
 		ui.cbBaudRate->hide();
 		ui.lBaudRate->hide();
 		ui.lHost->hide();
 		ui.leHost->hide();
 		ui.lPort->hide();
 		ui.lePort->hide();
 		ui.cbSerialPort->hide();
 		ui.lSerialPort->hide();
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
 		ui.lFileName->show();
 		ui.kleFileName->show();
 		ui.bOpen->show();
 
 		ui.bFileInfo->hide();
 		ui.cbBaudRate->hide();
 		ui.lBaudRate->hide();
 		ui.lHost->hide();
 		ui.leHost->hide();
 		ui.lPort->hide();
 		ui.lePort->hide();
 		ui.cbSerialPort->hide();
 		ui.lSerialPort->hide();
 		break;
 	case LiveDataSource::SourceType::NetworkTcpSocket:
 	case LiveDataSource::SourceType::NetworkUdpSocket:
 		ui.lHost->show();
 		ui.leHost->show();
 		ui.lePort->show();
 		ui.lPort->show();
 
 		ui.lBaudRate->hide();
 		ui.cbBaudRate->hide();
 		ui.lSerialPort->hide();
 		ui.cbSerialPort->hide();
 
 		ui.lFileName->hide();
 		ui.kleFileName->hide();
 		ui.bFileInfo->hide();
 		ui.bOpen->hide();
 		break;
 	case LiveDataSource::SourceType::SerialPort:
 		ui.lBaudRate->show();
 		ui.cbBaudRate->show();
 		ui.lSerialPort->show();
 		ui.cbSerialPort->show();
 
 		ui.lHost->hide();
 		ui.leHost->hide();
 		ui.lePort->hide();
 		ui.lPort->hide();
 		ui.lFileName->hide();
 		ui.kleFileName->hide();
 		ui.bFileInfo->hide();
 		ui.bOpen->hide();
 		break;
 	default:
 		break;
 	}
 
 	emit sourceTypeChanged();
 }
 
 void ImportFileWidget::initializeAndFillPortsAndBaudRates() {
 	for (int i = 2; i < ui.swOptions->count(); ++i)
 		ui.swOptions->removeWidget(ui.swOptions->widget(i));
 
 	const int size = ui.cbFileType->count();
 	for (int i = 2; i < size; ++i)
 		ui.cbFileType->removeItem(2);
 
 	ui.cbBaudRate->hide();
 	ui.lBaudRate->hide();
 
 	ui.lHost->hide();
 	ui.leHost->hide();
 
 	ui.lPort->hide();
 	ui.lePort->hide();
 
 	ui.cbSerialPort->hide();
 	ui.lSerialPort->hide();
 
 	ui.cbBaudRate->addItems(LiveDataSource::supportedBaudRates());
 	ui.cbSerialPort->addItems(LiveDataSource::availablePorts());
 
 	ui.leKeepLastValues->setValidator(new QIntValidator(2, 100000));
 	ui.tabWidget->removeTab(2);
 }
diff --git a/src/kdefrontend/datasources/ImportFileWidget.h b/src/kdefrontend/datasources/ImportFileWidget.h
index 93b796a5a..3cd46540f 100644
--- a/src/kdefrontend/datasources/ImportFileWidget.h
+++ b/src/kdefrontend/datasources/ImportFileWidget.h
@@ -1,113 +1,113 @@
 /***************************************************************************
     File                 : ImportFileWidget.h
     Project              : LabPlot
     Description          : import file data widget
     --------------------------------------------------------------------
     Copyright            : (C) 2009-2017 by Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
     Copyright            : (C) 2009-2015 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2017 Fabian Kristof (fkristofszabolcs@gmail.com)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 #ifndef IMPORTFILEWIDGET_H
 #define IMPORTFILEWIDGET_H
 
 #include "ui_importfilewidget.h"
 #include "backend/datasources/LiveDataSource.h"
 #include <memory>
 
 class AbstractFileFilter;
 class AsciiOptionsWidget;
 class BinaryOptionsWidget;
 class HDFOptionsWidget;
 class ImageOptionsWidget;
 class NetCDFOptionsWidget;
 class FITSOptionsWidget;
 class QTableWidget;
 
 class ImportFileWidget : public QWidget {
 	Q_OBJECT
 
 public:
 	explicit ImportFileWidget(QWidget*, const QString& fileName = QString());
 	~ImportFileWidget();
 
 	void showOptions(bool);
 	void saveSettings(LiveDataSource*) const;
 	LiveDataSource::FileType currentFileType() const;
 	LiveDataSource::SourceType currentSourceType() const;
 	AbstractFileFilter* currentFileFilter() const;
 	QString fileName() const;
 	const QStringList selectedHDFNames() const;
 	const QStringList selectedNetCDFNames() const;
 	const QStringList selectedFITSExtensions() const;
 	void hideDataSource();
 	void showAsciiHeaderOptions(bool);
 
 	QString host() const;
 	QString port() const;
-	int serialPort() const;
-
+    QString serialPort() const;
+    int baudRate() const;
 	void initializeAndFillPortsAndBaudRates();
 
 private:
 
 	Ui::ImportFileWidget ui;
 
 	std::unique_ptr<AsciiOptionsWidget> m_asciiOptionsWidget;
 	std::unique_ptr<BinaryOptionsWidget> m_binaryOptionsWidget;
 	std::unique_ptr<HDFOptionsWidget> m_hdfOptionsWidget;
 	std::unique_ptr<ImageOptionsWidget> m_imageOptionsWidget;
 	std::unique_ptr<NetCDFOptionsWidget> m_netcdfOptionsWidget;
 	std::unique_ptr<FITSOptionsWidget> m_fitsOptionsWidget;
 	QTableWidget* m_twPreview;
 	const QString& m_fileName;
 	bool m_liveDataSource;
 
 private slots:
 	void fileNameChanged(const QString&);
 	void fileTypeChanged(int);
 
 	void updateTypeChanged(int);
 	void sourceTypeChanged(int);
 	void readingTypeChanged(int);
 
 	void saveFilter();
 	void manageFilters();
 	void filterChanged(int);
 	void selectFile();
 	void fileInfoDialog();
 	void refreshPreview();
 	void loadSettings();
 
 signals:
 	void fileNameChanged();
 	void sourceTypeChanged();
 	void hostChanged();
 	void portChanged();
 
 	void checkedFitsTableToMatrix(const bool enable);
 
 	friend class HDFOptionsWidget;	// to access refreshPreview()
 	friend class NetCDFOptionsWidget;	// to access refreshPreview() and others
 };
 
 #endif
diff --git a/tests/import_export/ASCII/scripts/server_cpu_udp_socket.py b/tests/import_export/ASCII/scripts/server_cpu_udp_socket.py
index 627411a5e..cf2d9117e 100755
--- a/tests/import_export/ASCII/scripts/server_cpu_udp_socket.py
+++ b/tests/import_export/ASCII/scripts/server_cpu_udp_socket.py
@@ -1,15 +1,15 @@
 #!/usr/bin/python
 
 import socket
 import psutil
 
 HOST = 'localhost'
 PORT = 1027
 ADDR = (HOST,PORT)
 serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-
+serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 while True:
   cpu_percent = str(psutil.cpu_percent(interval=0.5))
   serv.sendto(cpu_percent, ADDR)
   print 'written ' + cpu_percent