diff --git a/src/backend/datasources/LiveDataSource.cpp b/src/backend/datasources/LiveDataSource.cpp
index 745765cd8..ce0fedf35 100644
--- a/src/backend/datasources/LiveDataSource.cpp
+++ b/src/backend/datasources/LiveDataSource.cpp
@@ -1,1032 +1,1032 @@
 /***************************************************************************
 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, &QTimer::timeout, this, &LiveDataSource::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, &QAction::triggered, this, &LiveDataSource::read);
 
 	m_toggleLinkAction = new QAction(i18n("Link the file"), this);
 	m_toggleLinkAction->setCheckable(true);
 	connect(m_toggleLinkAction, &QAction::triggered, this, &LiveDataSource::linkToggled);
 
 	m_plotDataAction = new QAction(QIcon::fromTheme("office-chart-line"), i18n("Plot data"), this);
 	connect(m_plotDataAction, &QAction::triggered, this, &LiveDataSource::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, &QFileSystemWatcher::fileChanged, this, &LiveDataSource::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, &QFileSystemWatcher::fileChanged, this, &LiveDataSource::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) {
+void LiveDataSource::setLocalSocketName(const QString& name) {
 	m_localSocketName = name;
 }
 
 QString LiveDataSource::localSocketName() const {
 	return m_localSocketName;
 }
 
-void LiveDataSource::setFileType(const FileType type) {
+void LiveDataSource::setFileType(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) {
+void LiveDataSource::setFileWatched(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) {
+void LiveDataSource::setKeepLastValues(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) {
+void LiveDataSource::setBaudRate(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) {
+void LiveDataSource::setUpdateInterval(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) {
+void LiveDataSource::setKeepNvalues(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) {
+void LiveDataSource::setPort(quint16 port) {
 	m_port = port;
 }
 
-void LiveDataSource::setBytesRead(const qint64 bytes) {
+void LiveDataSource::setBytesRead(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) {
+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) {
+void LiveDataSource::setSampleRate(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) {
+void LiveDataSource::setSourceType(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) {
+void LiveDataSource::setReadingType(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) {
+void LiveDataSource::setUpdateType(UpdateType updatetype) {
 	if (updatetype == NewData) {
 		m_updateTimer->stop();
 		if (m_fileSystemWatcher == nullptr)
 			watch();
 		else
 			connect(m_fileSystemWatcher, &QFileSystemWatcher::fileChanged, this, &LiveDataSource::read);
 	} else {
 		if (m_fileSystemWatcher)
 			disconnect(m_fileSystemWatcher, &QFileSystemWatcher::fileChanged, this, &LiveDataSource::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) {
+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) {
+void LiveDataSource::setFileLinked(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, &QTcpSocket::readyRead, this, &LiveDataSource::readyRead);
 			connect(m_tcpSocket, static_cast<void (QTcpSocket::*) (QAbstractSocket::SocketError)>(&QTcpSocket::error), this, &LiveDataSource::tcpSocketError);
 			qDebug() << "socket state after preparing: " << m_tcpSocket->state();
 
 			break;
 		case NetworkUdpSocket:
 			m_udpSocket = new QUdpSocket(this);
 
 			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;
 			connect(m_udpSocket, &QUdpSocket::readyRead, this, &LiveDataSource::readyRead);
 			connect(m_udpSocket, static_cast<void (QUdpSocket::*) (QAbstractSocket::SocketError)>(&QUdpSocket::error), this, &LiveDataSource::tcpSocketError);
 			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, &QLocalSocket::readyRead, this, &LiveDataSource::readyRead);
 			connect(m_localSocket, static_cast<void (QLocalSocket::*) (QLocalSocket::LocalSocketError)>(&QLocalSocket::error), this, &LiveDataSource::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, static_cast<void (QSerialPort::*) (QSerialPort::SerialPortError)>(&QSerialPort::error), this, &LiveDataSource::serialPortError);
 			connect(m_serialPort, &QSerialPort::readyRead, this, &LiveDataSource::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;
 		case Image:
 		case HDF:
 		case NETCDF:
 		case FITS:
 			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->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) {
 	Q_UNUSED(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) {
 	Q_UNUSED(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;
 	case QSerialPort::ParityError:
 	case QSerialPort::FramingError:
 	case QSerialPort::BreakConditionError:
 	case QSerialPort::WriteError:
 	case QSerialPort::UnsupportedOperationError:
 	case QSerialPort::UnknownError:
 		QMessageBox::critical(0, i18n("Serial Port Error"),
 		                      i18n("The following error occurred: %1.").arg(m_serialPort->errorString()));
 		break;
 	case QSerialPort::NoError:
 		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, &QFileSystemWatcher::fileChanged, this, &LiveDataSource::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"))) {
 			infoStrings << i18n("Images: %1", QString::number(FITSFilter::imagesCount(fileName) ));
 			infoStrings << i18n("Tables: %1", QString::number(FITSFilter::tablesCount(fileName) ));
 		}
 #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/backend/datasources/LiveDataSource.h b/src/backend/datasources/LiveDataSource.h
index 208e8b1f2..90d3fdec8 100644
--- a/src/backend/datasources/LiveDataSource.h
+++ b/src/backend/datasources/LiveDataSource.h
@@ -1,211 +1,211 @@
 /***************************************************************************
     File                 : LiveDataSource.h
     Project              : LabPlot
     Description          : File data source
     --------------------------------------------------------------------
     Copyright            : (C) 2012-2013 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 LIVEDATASOURCE_H
 #define LIVEDATASOURCE_H
 
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 
 #include <QSerialPort>
 #include <QLocalSocket>
 #include <QTimer>
 
 class QString;
 class AbstractFileFilter;
 class QFileSystemWatcher;
 class QAction;
 class QTcpSocket;
 class QUdpSocket;
 class QFile;
 
 class LiveDataSource : public Spreadsheet {
 	Q_OBJECT
 	Q_ENUMS(FileType)
 
 public:
 	enum FileType {Ascii, Binary, Image, HDF, NETCDF, FITS};
 	enum SourceType {
 		FileOrPipe = 0,
 		NetworkTcpSocket,
 		NetworkUdpSocket,
 		LocalSocket,
 		SerialPort
 	};
 
 	enum UpdateType {
 		TimeInterval = 0,
 		NewData
 	};
 
 	enum ReadingType {
 		ContinousFixed = 0,
 		FromEnd,
 		TillEnd
 	};
 
 	LiveDataSource(AbstractScriptingEngine*, const QString& name, bool loading = false);
 	~LiveDataSource();
 
 	void ready();
 
 	static QStringList supportedBaudRates();
 	static QStringList availablePorts();
 
 	static QStringList fileTypes();
 	static QString fileInfoString(const QString&);
 
 	void setFileType(const FileType);
 	FileType fileType() const;
 
 	UpdateType updateType() const;
-	void setUpdateType(const UpdateType);
+	void setUpdateType(UpdateType);
 
 	SourceType sourceType() const;
-	void setSourceType(const SourceType);
+	void setSourceType(SourceType);
 
 	ReadingType readingType() const;
-	void setReadingType(const ReadingType);
+	void setReadingType(ReadingType);
 
 	int sampleRate() const;
-	void setSampleRate(const int);
+	void setSampleRate(int);
 
-	void setBytesRead(const qint64 bytes);
+	void setBytesRead(qint64 bytes);
 	int bytesRead() const;
 
 	int port() const;
-	void setPort(const int);
+	void setPort(quint16);
 
 	bool isPaused() const;
 
 	void setSerialPort(const QString& name);
 	QString serialPortName() const;
 
 	QString host() const;
 	void setHost(const QString&);
 
 	int baudRate() const;
-	void setBaudRate(const int);
+	void setBaudRate(int);
 
-	void setUpdateInterval(const int);
+	void setUpdateInterval(int);
 	int updateInterval() const;
 
-	void setKeepNvalues(const int);
+	void setKeepNvalues(int);
 	int keepNvalues() const;
 
-	void setKeepLastValues(const bool);
+	void setKeepLastValues(bool);
 	bool keepLastValues() const;
 
-	void setFileWatched(const bool);
+	void setFileWatched(bool);
 	bool isFileWatched() const;
 
-	void setFileLinked(const bool);
+	void setFileLinked(bool);
 	bool isFileLinked() const;
 
 	void setFileName(const QString&);
 	QString fileName() const;
 
 	void setLocalSocketName(const QString&);
 	QString localSocketName() const;
 
 	void updateNow();
 	void pauseReading();
 	void continueReading();
 
 	void setFilter(AbstractFileFilter*);
 	AbstractFileFilter* filter() const;
 
 	virtual QIcon icon() const override;
 	virtual QMenu* createContextMenu() override;
 	virtual QWidget* view() const override;
 
 	virtual void save(QXmlStreamWriter*) const override;
 	virtual bool load(XmlStreamReader*, bool preview) override;
 
 private:
 	void initActions();
 	void watch();
 
 	QString m_fileName;
 	QString m_serialPortName;
 	QString m_localSocketName;
 	QString m_host;
 
 	FileType m_fileType;
 	UpdateType m_updateType;
 	SourceType m_sourceType;
 	ReadingType m_readingType;
 
 	bool m_fileWatched;
 	bool m_fileLinked;
 	bool m_paused;
 	bool m_prepared;
 	bool m_keepLastValues;
 
 	int m_sampleRate;
 	int m_keepNvalues;
 	int m_updateInterval;
-	int m_port;
+	quint16 m_port;
 	int m_baudRate;
 
 	qint64 m_bytesRead;
 
 	AbstractFileFilter* m_filter;
 
 	QTimer* m_updateTimer;
 	QFileSystemWatcher* m_fileSystemWatcher;
 
 	QFile* m_file;
 	QLocalSocket* m_localSocket;
 	QTcpSocket* m_tcpSocket;
 	QUdpSocket* m_udpSocket;
 	QSerialPort* m_serialPort;
 	QIODevice* m_device;
 
 	QAction* m_reloadAction;
 	QAction* m_toggleLinkAction;
 	QAction* m_showEditorAction;
 	QAction* m_showSpreadsheetAction;
 	QAction* m_plotDataAction;
 
 public slots:
 	void read();
 
 private slots:
 	void watchToggled();
 	void linkToggled();
 	void plotData();
 
 	void readyRead();
 
 	void localSocketError(QLocalSocket::LocalSocketError);
 	void tcpSocketError(QAbstractSocket::SocketError);
 	void serialPortError(QSerialPort::SerialPortError);
 };
 
 #endif
diff --git a/src/kdefrontend/datasources/ImportFileWidget.cpp b/src/kdefrontend/datasources/ImportFileWidget.cpp
index 51465ba5e..fcfebd453 100644
--- a/src/kdefrontend/datasources/ImportFileWidget.cpp
+++ b/src/kdefrontend/datasources/ImportFileWidget.cpp
@@ -1,1070 +1,1070 @@
 /***************************************************************************
 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 <QCompleter>
 #include <QDir>
 #include <QDirModel>
 #include <QFileDialog>
 #include <QImageReader>
 #include <QInputDialog>
 #include <QIntValidator>
 #include <QLocalSocket>
 #include <QProcess>
 #include <QStandardItemModel>
 #include <QTableWidget>
 #include <QTcpSocket>
 #include <QTimer>
 #include <QUdpSocket>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 /*!
    \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_fileEmpty(false),
 	m_liveDataSource(true) {
 	ui.setupUi(this);
 
 	QCompleter* completer = new QCompleter(this);
 	completer->setModel(new QDirModel);
 	ui.leFileName->setCompleter(completer);
 
 	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.leFileName, 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.leFileName->setText(conf.readEntry("LastImportedFile", ""));
 	else
 		ui.leFileName->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.leFileName->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.leFileName->text() + QLatin1String("[") + extensionName + QLatin1String("]");
 	}
 
 	return ui.leFileName->text();
 }
 
 /*!
  * returns \c true if the number of lines to be imported from the currently selected file is zero ("file is empty"),
  * returns \c false otherwise.
  */
 bool ImportFileWidget::isFileEmpty() const {
 	return m_fileEmpty;
 }
 
 QString ImportFileWidget::host() const {
 	return ui.leHost->text();
 }
 
 QString ImportFileWidget::port() const {
 	return ui.lePort->text();
 }
 
 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.leFileName->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.leFileName->text() );
 		source->setFileLinked( ui.chbLinkFile->isChecked() );
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
 		source->setLocalSocketName(ui.leFileName->text());
 		break;
 	case LiveDataSource::SourceType::NetworkTcpSocket:
 	case LiveDataSource::SourceType::NetworkUdpSocket:
 		source->setHost(ui.leHost->text());
-		source->setPort(ui.lePort->text().toInt());
+		source->setPort((quint16)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.leFileName->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.leFileName->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.leFileName->setStyleSheet("");
 	else
 		ui.leFileName->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.leFileName->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.leFileName->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.leFileName->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 = static_cast<AsciiFilter*>(this->currentFileFilter());
 
 			switch (currentSourceType()) {
 			case LiveDataSource::SourceType::FileOrPipe: {
 					importedStrings = filter->preview(fileName, lines);
 					break;
 				}
 			case LiveDataSource::SourceType::LocalSocket: {
 
 					QLocalSocket* lsocket = new QLocalSocket(this);
 					lsocket->connectToServer(fileName, QLocalSocket::ReadOnly);
 					bool localSocketConnected = lsocket->waitForConnected(2000);
 
 					if (localSocketConnected) {
 						qDebug() << "localPreviewConnected";
 						bool canread = lsocket->waitForReadyRead(500);
 						if (canread)
 							importedStrings = filter->preview(*lsocket);
 					}
 					if (lsocket->state() == QLocalSocket::ConnectedState) {
 						lsocket->disconnectFromServer();
 						connect(lsocket, SIGNAL(disconnected()), lsocket, SLOT(deleteLater()));
 					} else
 						delete lsocket;
 
 					break;
 				}
 			case LiveDataSource::SourceType::NetworkTcpSocket: {
 					QTcpSocket* tsocket = new QTcpSocket(this);
 					tsocket->connectToHost(host(), port().toInt(), QTcpSocket::ReadOnly);
 					bool tcpSocketConnected = tsocket->waitForConnected(2000);
 
 					if (tcpSocketConnected) {
 						bool canread = tsocket->waitForReadyRead(500);
 						qDebug() << "tcpPreviewconnected";
 						if (canread)
 							importedStrings = filter->preview(*tsocket);
 					}
 
 					if (tsocket->state() == QTcpSocket::ConnectedState) {
 						tsocket->disconnectFromHost();
 						connect(tsocket, SIGNAL(disconnected()), tsocket, SLOT(deleteLater()));
 					} else
 						delete tsocket;
 
 					break;
 				}
 			case LiveDataSource::SourceType::NetworkUdpSocket: {
 					QUdpSocket* usocket = new QUdpSocket(this);
 					usocket->connectToHost(host(), port().toInt(), QUdpSocket::ReadOnly);
 					bool udpSocketConnected = usocket->waitForConnected(2000);
 
 					if (udpSocketConnected) {
 						bool canread = usocket->waitForReadyRead(500);
 						qDebug() << "tcpPreviewconnected";
 						if (canread)
 							importedStrings = filter->preview(*usocket);
 					}
 
 					if (usocket->state() == QUdpSocket::ConnectedState) {
 						usocket->disconnectFromHost();
 						connect(usocket, SIGNAL(disconnected()), usocket, SLOT(deleteLater()));
 					} else
 						delete usocket;
 
 					break;
 				}
 			case LiveDataSource::SourceType::SerialPort: {
 					QSerialPort* sPort = new QSerialPort(this);
 
 					sPort->setBaudRate(baudRate());
 					sPort->setPortName(serialPort());
 
 					bool serialPortOpened = sPort->open(QIODevice::ReadOnly);
 					if (serialPortOpened) {
 
 					}
 					break;
 				}
 			}
 
 			tmpTableWidget = m_twPreview;
 			vectorNameList = filter->vectorNames();
 			columnModes = filter->columnModes();
 			break;
 		}
 	case LiveDataSource::Binary: {
 			ui.tePreview->clear();
 			BinaryFilter *filter = (BinaryFilter *)this->currentFileFilter();
 			importedStrings = filter->preview(fileName, 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);
 		m_fileEmpty = false;
 	} else {
 		m_fileEmpty = true;
 	}
 	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.leFileName->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.leFileName->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.leFileName->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.leFileName->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);
 }