diff --git a/src/backend/core/AbstractAspect.cpp b/src/backend/core/AbstractAspect.cpp
index 170fd4f31..5d773fec5 100644
--- a/src/backend/core/AbstractAspect.cpp
+++ b/src/backend/core/AbstractAspect.cpp
@@ -1,837 +1,837 @@
 /***************************************************************************
     File                 : AbstractAspect.cpp
     Project              : LabPlot
     --------------------------------------------------------------------
     Copyright            : (C) 2007-2009 by Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2007-2010 by Knut Franke (knut.franke@gmx.de)
     Copyright            : (C) 2011-2016 by Alexander Semke (alexander.semke@web.de)
     Description          : Base class for all objects in a Project.
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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/core/AbstractAspect.h"
 #include "backend/core/AspectPrivate.h"
 #include "backend/core/aspectcommands.h"
 #include "backend/core/Project.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/datapicker/DatapickerCurve.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/SignallingUndoCommand.h"
 #include "backend/lib/PropertyChangeCommand.h"
 
 #include <QMenu>
 
 /**
  * \class AbstractAspect
  * \brief Base class of all persistent objects in a Project.
  *
  * Before going into the details, it's useful to understand the ideas behind the
  * \ref aspect "Aspect Framework".
  *
  * Aspects organize themselves into trees, where a parent takes ownership of its children. Usually,
  * though not necessarily, a Project instance will sit at the root of the tree (without a Project
  * ancestor, project() will return 0 and undo does not work). Children are organized using
  * addChild(), removeChild(), child(), indexOfChild() and childCount() on the parent's side as well
  * as the equivalent convenience methods index() and remove() on the child's side.
  * In contrast to the similar feature of QObject, Aspect trees are fully undo/redo aware and provide
  * signals around object adding/removal.
  *
  * AbstractAspect manages for every Aspect the properties #name, #comment, #captionSpec and
  * #creationTime. All of these translate into the caption() as described in the documentation
  * of setCaptionSpec().
  *
  * If an undoStack() can be found (usually it is managed by Project), changes to the properties
  * as well as adding/removing children support multi-level undo/redo. In order to support undo/redo
  * for problem-specific data in derived classes, make sure that all changes to your data are done
  * by handing appropriate commands to exec().
  */
 
 /**
  * \enum AbstractAspect::ChildIndexFlag
  * \brief Flags which control numbering scheme of children.
  */
 /**
  * \var AbstractAspect::IncludeHidden
  * \brief Include aspects marked as "hidden" in numbering or listing children.
  */
 /**
  * \var AbstractAspect::Recursive
  * \brief Recursively handle all descendents, not just immediate children.
  */
 /**
  * \var AbstractAspect::Compress
  * \brief Remove all null pointers from the result list.
  */
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // documentation of template and inline methods
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \fn template < class T > T *AbstractAspect::ancestor() const
  * \brief Return the closest ancestor of class T (or NULL if none found).
  */
 
 /**
  * \fn template < class T > QVector<T*> AbstractAspect::children(const ChildIndexFlags &flags=0) const
  * \brief Return list of children inheriting from class T.
  *
  * Use AbstractAspect for T in order to get all children.
  */
 
 /**
  * \fn template < class T > T *AbstractAspect::child(int index, const ChildIndexFlags &flags=0) const
  * \brief Return child identified by (0 based) index and class.
  *
  * Identifying objects by an index is inherently error-prone and confusing,
  * given that the index can be based on different criteria (viz, counting
  * only instances of specific classes and including/excluding hidden
  * aspects). Therefore, it is recommended to avoid indices wherever possible
  * and instead refer to aspects using AbstractAspect pointers.
  */
 
 /**
  * \fn template < class T > T *AbstractAspect::child(const QString &name) const
  * \brief Get child by name and class.
  */
 
 /**
  * \fn template < class T > int AbstractAspect::childCount(const ChildIndexFlags &flags=0) const
  * \brief Return the number of child Aspects inheriting from given class.
  */
 
 /**
  * \fn template < class T > int AbstractAspect::indexOfChild(const AbstractAspect * child, const ChildIndexFlags &flags=0) const
  * \brief Return (0 based) index of child in the list of children inheriting from class T.
  */
 
 /**
  * \fn void AbstractAspect::aspectDescriptionAboutToChange(const AbstractAspect *aspect)
  * \brief Emitted before the name, comment or caption spec is changed
  */
 
 /**
  * \fn void AbstractAspect::aspectDescriptionChanged(const AbstractAspect *aspect)
  * \brief Emitted after the name, comment or caption spec have changed
  */
 
 /**
  * \fn void AbstractAspect::aspectAboutToBeAdded(const AbstractAspect *parent, const AbstractAspect *before, const AbstractAspect * child)
  * \brief Emitted before a new child is inserted
  */
 
 /**
  * \fn void AbstractAspect::aspectAdded(const AbstractAspect *aspect)
  * \brief Emitted after a new Aspect has been added to the tree
  */
 
 /**
  * \fn void AbstractAspect::aspectAboutToBeRemoved(const AbstractAspect *aspect)
  * \brief Emitted before an aspect is removed from its parent
  */
 
 /**
  * \fn void AbstractAspect::aspectRemoved(const AbstractAspect *parent, const AbstractAspect * before, const AbstractAspect * child)
  * \brief Emitted from the parent after removing a child
  */
 
 /**
  * \fn void AbstractAspect::aspectHiddenAboutToChange(const AbstractAspect *aspect)
  * \brief Emitted before the hidden attribute is changed
  */
 
 /**
  * \fn void AbstractAspect::aspectHiddenChanged(const AbstractAspect *aspect)
  * \brief Emitted after the hidden attribute has changed
  */
 
 /**
  * \fn void AbstractAspect::statusInfo(const QString &text)
  * \brief Emitted whenever some aspect in the tree wants to give status information to the user
  * \sa info(const QString&)
  */
 
 /**
  * \fn protected void AbstractAspect::info(const QString &text)
  * \brief Implementations should call this whenever status information should be given to the user.
  *
  * This will cause statusInfo() to be emitted. Typically, this will cause the specified string
  * to be displayed in a status bar, a log window or some similar non-blocking way so as not to
  * disturb the workflow.
  */
 
 /**
  * \fn protected virtual void childSelected(const AbstractAspect*){}
  * \brief called when a child's child aspect was selected in the model
  */
 
 /**
  * \fn protected virtual void childDeselected()
  * \brief called when a child aspect was deselected in the model
  */
 
 /**
  * \fn protected virtual void childDeselected(const AbstractAspect*)
  * \brief called when a child's child aspect was deselected in the model
  */
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // start of AbstractAspect implementation
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 AbstractAspect::AbstractAspect(const QString &name)
 	: d(new AbstractAspectPrivate(this, name))
 {
 }
 
 AbstractAspect::~AbstractAspect() {
 	delete d;
 }
 
 QString AbstractAspect::name() const {
 	return d->m_name;
 }
 
 void AbstractAspect::setName(const QString &value) {
 	if (value.isEmpty()) {
 		setName(QLatin1String("1"));
 		return;
 	}
 
 	if (value == d->m_name)
 		return;
 
 	QString new_name;
 	if (d->m_parent) {
 		new_name = d->m_parent->uniqueNameFor(value);
 		if (new_name != value)
 			info(i18n("Intended name \"%1\" was changed to \"%2\" in order to avoid name collision.", value, new_name));
 	} else {
 		new_name = value;
 	}
 
 	exec(new PropertyChangeCommand<QString>(i18n("%1: rename to %2", d->m_name, new_name),
 				&d->m_name, new_name),
 			"aspectDescriptionAboutToChange", "aspectDescriptionChanged", Q_ARG(const AbstractAspect*,this));
 }
 
 QString AbstractAspect::comment() const {
 	return d->m_comment;
 }
 
 void AbstractAspect::setComment(const QString& value) {
 	if (value == d->m_comment) return;
 	exec(new PropertyChangeCommand<QString>(i18n("%1: change comment", d->m_name),
 				&d->m_comment, value),
 			"aspectDescriptionAboutToChange", "aspectDescriptionChanged", Q_ARG(const AbstractAspect*,this));
 }
 
 void AbstractAspect::setCreationTime(const QDateTime& time) {
 	d->m_creation_time = time;
 }
 
 QDateTime AbstractAspect::creationTime() const {
 	return d->m_creation_time;
 }
 
 bool AbstractAspect::hidden() const {
     return d->m_hidden;
 }
 
 /**
  * \brief Set "hidden" property, i.e. whether to exclude this aspect from being shown in the explorer.
  */
 void AbstractAspect::setHidden(bool value) {
     if (value == d->m_hidden) return;
     exec(new PropertyChangeCommand<bool>(i18n("%1: change hidden status", d->m_name),
 				 &d->m_hidden, value),
 			"aspectHiddenAboutToChange", "aspectHiddenChanged", Q_ARG(const AbstractAspect*,this));
 }
 
 void AbstractAspect::setIsLoading(bool load) {
 	d->m_isLoading = load;
 }
 
 bool AbstractAspect::isLoading() const {
 	return d->m_isLoading;
 }
 
 /**
  * \brief Return an icon to be used for decorating my views.
  */
 QIcon AbstractAspect::icon() const {
 	return QIcon();
 }
 
 /**
  * \brief Return a new context menu.
  *
  * The caller takes ownership of the menu.
  */
 QMenu* AbstractAspect::createContextMenu() {
 	QMenu* menu = new QMenu();
 	menu->addSection(this->name());
 	//TODO: activate this again when the functionality is implemented
 // 	menu->addAction( KStandardAction::cut(this) );
 // 	menu->addAction(KStandardAction::copy(this));
 // 	menu->addAction(KStandardAction::paste(this));
 // 	menu->addSeparator();
     menu->addAction(QIcon::fromTheme(QLatin1String("edit-rename")), i18n("Rename"), this, SIGNAL(renameRequested()));
 
 	//don't allow to delete data spreadsheets in the datapicker curves
     if ( !(dynamic_cast<const Spreadsheet*>(this) && dynamic_cast<const DatapickerCurve*>(this->parentAspect())) )
 		menu->addAction(QIcon::fromTheme(QLatin1String("edit-delete")), i18n("Delete"), this, SLOT(remove()));
 
 	return menu;
 }
 
 /**
  * \brief Return my parent Aspect or 0 if I currently don't have one.
  */
 AbstractAspect* AbstractAspect::parentAspect() const {
 	return d->m_parent;
 }
 
 void AbstractAspect::setParentAspect(AbstractAspect* parent) {
 	d->m_parent = parent;
 }
 
 /**
  * \brief Return the folder the Aspect is contained in or 0 if there is none.
  *
  * The returned folder may be the aspect itself if it inherits Folder.
  */
 Folder* AbstractAspect::folder() {
 	if(inherits("Folder")) return static_cast<Folder*>(this);
 	AbstractAspect* parent_aspect = parentAspect();
 	while(parent_aspect && !parent_aspect->inherits("Folder"))
 		parent_aspect = parent_aspect->parentAspect();
 	return static_cast<Folder*>(parent_aspect);
 }
 
 /**
  * \brief Return whether the there is a path upwards to the given aspect
  *
  * This also returns true if other==this.
  */
 bool AbstractAspect::isDescendantOf(AbstractAspect* other) {
 	if(other == this) return true;
 	AbstractAspect* parent_aspect = parentAspect();
 	while(parent_aspect) 	{
 		if(parent_aspect == other) return true;
 		parent_aspect = parent_aspect->parentAspect();
 	}
 	return false;
 }
 
 /**
  * \brief Return the Project this Aspect belongs to, or 0 if it is currently not part of one.
  */
 Project* AbstractAspect::project() {
 	return parentAspect() ? parentAspect()->project() : nullptr;
 }
 
 /**
  * \brief Return the path that leads from the top-most Aspect (usually a Project) to me.
  */
 QString AbstractAspect::path() const {
 	return parentAspect() ? parentAspect()->path() + QLatin1Char('/') + name() : QLatin1String("");
 }
 
 /**
  * \brief Add the given Aspect to my list of children.
  */
 void AbstractAspect::addChild(AbstractAspect* child) {
 	Q_CHECK_PTR(child);
 
 	QString new_name = uniqueNameFor(child->name());
 	beginMacro(i18n("%1: add %2", name(), new_name));
 	if (new_name != child->name()) {
 		info(i18n("Renaming \"%1\" to \"%2\" in order to avoid name collision.", child->name(), new_name));
 		child->setName(new_name);
 	}
 
 	exec(new AspectChildAddCmd(d, child, d->m_children.count()));
 	child->finalizeAdd();
 	endMacro();
 }
 
 /**
  * \brief Add the given Aspect to my list of children without any checks and without putting this step onto the undo-stack
  */
 void AbstractAspect::addChildFast(AbstractAspect* child) {
 	emit aspectAboutToBeAdded(this, nullptr, child); //TODO: before-pointer is 0 here, also in the commands classes. why?
 	d->insertChild(d->m_children.count(), child);
 	child->finalizeAdd();
 	emit aspectAdded(child);
 }
 
 /**
  * \brief Insert the given Aspect at a specific position in my list of children.
  */
 void AbstractAspect::insertChildBefore(AbstractAspect* child, AbstractAspect* before) {
 	Q_CHECK_PTR(child);
 
 	QString new_name = uniqueNameFor(child->name());
 	beginMacro(before ? i18n("%1: insert %2 before %3", name(), new_name, before->name()) : i18n("%1: insert %2 before end", name(), new_name));
 	if (new_name != child->name()) {
 		info(i18n("Renaming \"%1\" to \"%2\" in order to avoid name collision.", child->name(), new_name));
 		child->setName(new_name);
 	}
 	int index = d->indexOfChild(before);
 	if (index == -1)
 		index = d->m_children.count();
 
 	exec(new AspectChildAddCmd(d, child, index));
 	endMacro();
 }
 
 /**
  * \brief Insert the given Aspect at a specific position in my list of children.without any checks and without putting this step onto the undo-stack
  */
 void AbstractAspect::insertChildBeforeFast(AbstractAspect* child, AbstractAspect* before) {
 	connect(child, &AbstractAspect::selected, this, &AbstractAspect::childSelected);
 	connect(child, &AbstractAspect::deselected, this, &AbstractAspect::childDeselected);
 
 	int index = d->indexOfChild(before);
 	if (index == -1)
 		index = d->m_children.count();
 
 	emit aspectAboutToBeAdded(this, nullptr, child);
 	d->insertChild(index, child);
 	emit aspectAdded(child);
 }
 
 /**
  * \brief Remove the given Aspect from my list of children.
  *
  * The ownership of the child is transferred to the undo command,
  * i.e., the aspect is deleted by the undo command.
  * \sa reparent()
  */
 void AbstractAspect::removeChild(AbstractAspect* child) {
 	Q_ASSERT(child->parentAspect() == this);
 	beginMacro(i18n("%1: remove %2", name(), child->name()));
 	exec(new AspectChildRemoveCmd(d, child));
 	endMacro();
 }
 
 /**
  * \brief Remove all child Aspects.
  */
 void AbstractAspect::removeAllChildren() {
 	beginMacro(i18n("%1: remove all children", name()));
 
 	QVector<AbstractAspect*> children_list = children();
 	QVector<AbstractAspect*>::const_iterator i = children_list.constBegin();
 	AbstractAspect *current = nullptr, *nextSibling = nullptr;
 	if (i != children_list.constEnd()) {
 		current = *i;
 		if (++i != children_list.constEnd())
 			nextSibling = *i;
 	}
 
 	while (current) {
 		emit aspectAboutToBeRemoved(current);
 		exec(new AspectChildRemoveCmd(d, current));
 		emit aspectRemoved(this, nextSibling, current);
 
 		current = nextSibling;
 		if (i != children_list.constEnd() && ++i != children_list.constEnd())
 			nextSibling = *i;
 		else
 			nextSibling = nullptr;
 	}
 
 	endMacro();
 }
 
 /**
  * \brief Move a child to another parent aspect and transfer ownership.
  */
 void AbstractAspect::reparent(AbstractAspect* newParent, int newIndex) {
 	Q_ASSERT(parentAspect() != nullptr);
 	Q_ASSERT(newParent != nullptr);
 	int max_index = newParent->childCount<AbstractAspect>(IncludeHidden);
 	if (newIndex == -1)
 		newIndex = max_index;
 	Q_ASSERT(newIndex >= 0 && newIndex <= max_index);
 
 	AbstractAspect* old_parent = parentAspect();
 	int old_index = old_parent->indexOfChild<AbstractAspect>(this, IncludeHidden);
 	AbstractAspect* old_sibling = old_parent->child<AbstractAspect>(old_index+1, IncludeHidden);
 	AbstractAspect* new_sibling = newParent->child<AbstractAspect>(newIndex, IncludeHidden);
 
 	//TODO check/test this!
 	emit aspectAboutToBeRemoved(this);
 	emit newParent->aspectAboutToBeAdded(newParent, new_sibling, this);
 	exec(new AspectChildReparentCmd(parentAspect()->d, newParent->d, this, newIndex));
 	emit old_parent->aspectRemoved(old_parent, old_sibling, this);
 	emit aspectAdded(this);
 
 	endMacro();
 }
 
 QVector<AbstractAspect*> AbstractAspect::children(const char* className, ChildIndexFlags flags) {
 	QVector<AbstractAspect*> result;
 	for (auto* child : children()) {
 		if (flags & IncludeHidden || !child->hidden()) {
 			if ( child->inherits(className) || !(flags & Compress)) {
 				result << child;
 				if (flags & Recursive){
 					result << child->children(className, flags);
 				}
 			}
 		}
 	}
 	return result;
 }
 
 const QVector<AbstractAspect*> AbstractAspect::children() const {
 	return d->m_children;
 }
 
 /**
  * \brief Remove me from my parent's list of children.
  */
 void AbstractAspect::remove() {
 	if(parentAspect())
 		parentAspect()->removeChild(this);
 }
 
 /*!
  * returns the list of all parent aspects (folders and sub-folders)
  */
 QVector<AbstractAspect*> AbstractAspect::dependsOn() const {
 	QVector<AbstractAspect*> aspects;
 	if (parentAspect())
 		aspects << parentAspect() << parentAspect()->dependsOn();
 
 	return aspects;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name serialize/deserialize
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \fn virtual void AbstractAspect::save(QXmlStreamWriter *) const
  * \brief Save as XML
  */
 
 /**
  * \fn virtual bool AbstractAspect::load(XmlStreamReader *)
  * \brief Load from XML
  *
  * XmlStreamReader supports errors as well as warnings. If only
  * warnings (non-critial errors) occur, this function must return
  * the reader at the end element corresponding to the current
  * element at the time the function was called.
  *
  * This function is normally intended to be called directly
  * after the ctor. If you want to call load on an aspect that
  * has been altered, you must make sure beforehand that
  * it is in the same state as after creation, e.g., remove
  * all its child aspects.
  *
  * \return false on error
  */
 
 /**
  * \brief Save the comment to XML
  */
 void AbstractAspect::writeCommentElement(QXmlStreamWriter * writer) const{
 	writer->writeStartElement(QLatin1String("comment"));
 	writer->writeCharacters(comment());
 	writer->writeEndElement();
 }
 
 /**
  * \brief Load comment from an XML element
  */
 bool AbstractAspect::readCommentElement(XmlStreamReader * reader){
 	setComment(reader->readElementText());
 	return true;
 }
 
 /**
  * \brief Save name and creation time to XML
  */
 void AbstractAspect::writeBasicAttributes(QXmlStreamWriter* writer) const {
 	writer->writeAttribute(QLatin1String("creation_time") , creationTime().toString(QLatin1String("yyyy-dd-MM hh:mm:ss:zzz")));
 	writer->writeAttribute(QLatin1String("name"), name());
 }
 
 /**
  * \brief Load name and creation time from XML
  *
  * \return false on error
  */
 bool AbstractAspect::readBasicAttributes(XmlStreamReader* reader){
 	const QXmlStreamAttributes& attribs = reader->attributes();
 
 	// name
 	QString str = attribs.value(QLatin1String("name")).toString();
 	if(str.isEmpty())
 		reader->raiseWarning(i18n("Attribute 'name' is missing or empty."));
 
 	d->m_name = str;
 
 	// creation time
 	str = attribs.value(QLatin1String("creation_time")).toString();
 	if(str.isEmpty()) {
 		reader->raiseWarning(i18n("Invalid creation time for '%1'. Using current time.", name()));
 		d->m_creation_time = QDateTime::currentDateTime();
 	} else {
 		QDateTime creation_time = QDateTime::fromString(str, QLatin1String("yyyy-dd-MM hh:mm:ss:zzz"));
 		if (creation_time.isValid())
 			d->m_creation_time = creation_time;
 		else
 			d->m_creation_time = QDateTime::currentDateTime();
 	}
 
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name undo related
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 void AbstractAspect::setUndoAware(bool b) {
 	d->m_undoAware = b;
 }
 
 /**
  * \brief Return the undo stack of the Project, or 0 if this Aspect is not part of a Project.
  *
  * It's also possible to construct undo-enabled Aspect trees without Project.
  * The only requirement is that the root Aspect reimplements undoStack() to get the
  * undo stack from somewhere (the default implementation just delegates to parentAspect()).
  */
 QUndoStack* AbstractAspect::undoStack() const {
 	return parentAspect() ? parentAspect()->undoStack() : nullptr;
 }
 
 /**
  * \brief Execute the given command, pushing it on the undoStack() if available.
  */
 void AbstractAspect::exec(QUndoCommand* cmd) {
 	Q_CHECK_PTR(cmd);
 	if (d->m_undoAware) {
 		QUndoStack *stack = undoStack();
 		if (stack)
 			stack->push(cmd);
 		else {
 			cmd->redo();
 			delete cmd;
 		}
 
 		if (project())
 			project()->setChanged(true);
 	} else {
 		cmd->redo();
 		delete cmd;
 	}
 }
 
 /**
  * \brief Execute command and arrange for signals to be sent before/after it is redone or undone.
  *
  * \arg \c command The command to be executed.
  * \arg \c preChangeSignal The name of the signal to be triggered before re-/undoing the command.
  * \arg \c postChangeSignal The name of the signal to be triggered after re-/undoing the command.
  * \arg <tt>val0,val1,val2,val3</tt> Arguments to the signals; to be given using Q_ARG().
  *
  * Signal arguments are given using the macro Q_ARG(typename, const value&). Since
  * the variable given as "value" will likely be out of scope when the signals are emitted, a copy
  * needs to be created. This uses QMetaType, which means that (non-trivial) argument types need to
  * be registered using qRegisterMetaType() before giving them to exec() (in particular, this also
  * goes for pointers to custom data types).
  *
  * \sa SignallingUndoCommand
  */
 void AbstractAspect::exec(QUndoCommand* command,
 		const char* preChangeSignal, const char* postChangeSignal,
 		QGenericArgument val0, QGenericArgument val1, QGenericArgument val2, QGenericArgument val3) {
 	beginMacro(command->text());
 	exec(new SignallingUndoCommand(QLatin1String("change signal"), this,
 				preChangeSignal, postChangeSignal, val0, val1, val2, val3));
 	exec(command);
 	exec(new SignallingUndoCommand(QLatin1String("change signal"), this,
 				postChangeSignal, preChangeSignal, val0, val1, val2, val3));
 	endMacro();
 }
 
 /**
  * \brief Begin an undo stack macro (series of commands)
  */
 void AbstractAspect::beginMacro(const QString& text) {
 	if (!d->m_undoAware)
 		return;
 
 	QUndoStack* stack = undoStack();
 	if (stack)
 		stack->beginMacro(text);
 }
 
 /**
  * \brief End the current undo stack macro
  */
 void AbstractAspect::endMacro() {
 	if (!d->m_undoAware)
 		return;
 
 	QUndoStack* stack = undoStack();
 	if (stack)
 		stack->endMacro();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
 /*!
  * this function is called when the selection in ProjectExplorer was changed.
  * forwards the selection/deselection to the parent aspect via emitting a signal.
  */
 void AbstractAspect::setSelected(bool s){
   if (s)
 	emit selected(this);
   else
 	emit deselected(this);
 }
 
 void AbstractAspect::childSelected(const AbstractAspect* aspect) {
 	//forward the signal to the highest possible level in the parent-child hierarchy
 	//e.g. axis of a plot was selected. Don't include parent aspects here that do not
 	//need to react on the selection of children: e.g. Folder or XYFitCurve with
 	//the child column for calculated residuals
 	if (aspect->parentAspect() != nullptr
 		&& !aspect->parentAspect()->inherits("Folder")
 		&& !aspect->parentAspect()->inherits("XYFitCurve")
 		&& !aspect->parentAspect()->inherits("CantorWorksheet"))
 		emit aspect->parentAspect()->selected(aspect);
 }
 
 void AbstractAspect::childDeselected(const AbstractAspect* aspect) {
 	//forward the signal to the highest possible level in the parent-child hierarchy
 	//e.g. axis of a plot was selected. Don't include parent aspects here that do not
 	//need to react on the deselection of children: e.g. Folder or XYFitCurve with
 	//the child column for calculated residuals
 	if (aspect->parentAspect() != nullptr
 		&& !aspect->parentAspect()->inherits("Folder")
 		&& !aspect->parentAspect()->inherits("XYFitCurve")
 		&& !aspect->parentAspect()->inherits("CantorWorksheet"))
 		emit aspect->parentAspect()->deselected(aspect);
 }
 
 /**
  * \brief Make the specified name unique among my children by incrementing a trailing number.
  */
 QString AbstractAspect::uniqueNameFor(const QString& current_name) const {
 	QStringList child_names;
 	for (auto* child : children())
 		child_names << child->name();
 
 	if (!child_names.contains(current_name))
 		return current_name;
 
 	QString base = current_name;
 	int last_non_digit;
 	for (last_non_digit = base.size()-1; last_non_digit>=0 &&
 	        base[last_non_digit].category() == QChar::Number_DecimalDigit; --last_non_digit)
 		base.chop(1);
 
 	if (last_non_digit >=0 && base[last_non_digit].category() != QChar::Separator_Space)
 		base.append(" ");
 
 	int new_nr = current_name.rightRef(current_name.size() - base.size()).toInt();
 	QString new_name;
 	do
 		new_name = base + QString::number(++new_nr);
 	while (child_names.contains(new_name));
 
 	return new_name;
 }
 
 void AbstractAspect::connectChild(AbstractAspect* child) {
 	connect(child, &AbstractAspect::aspectDescriptionAboutToChange, this, &AbstractAspect::aspectDescriptionAboutToChange);
 	connect(child, &AbstractAspect::aspectDescriptionChanged, this, &AbstractAspect::aspectDescriptionChanged);
 	connect(child, &AbstractAspect::aspectAboutToBeAdded, this, &AbstractAspect::aspectAboutToBeAdded);
 	connect(child, &AbstractAspect::aspectAdded, this, &AbstractAspect::aspectAdded);
 	connect(child, &AbstractAspect::aspectAboutToBeRemoved, this, &AbstractAspect::aspectAboutToBeRemoved);
 	connect(child, &AbstractAspect::aspectRemoved, this, &AbstractAspect::aspectRemoved);
 	connect(child, &AbstractAspect::aspectHiddenAboutToChange, this, &AbstractAspect::aspectHiddenAboutToChange);
 	connect(child, &AbstractAspect::aspectHiddenChanged, this, &AbstractAspect::aspectHiddenChanged);
 	connect(child, &AbstractAspect::statusInfo, this, &AbstractAspect::statusInfo);
 
 	connect(child, &AbstractAspect::selected, this, &AbstractAspect::childSelected);
 	connect(child, &AbstractAspect::deselected, this, &AbstractAspect::childDeselected);
 }
 
 //##############################################################################
 //######################  Private implementation ###############################
 //##############################################################################
 AbstractAspectPrivate::AbstractAspectPrivate(AbstractAspect* owner, const QString& name)
 	: m_name(name.isEmpty() ? QLatin1String("1") : name), m_hidden(false), q(owner), m_parent(nullptr),
 	m_undoAware(true), m_isLoading(false)
 {
 	m_creation_time = QDateTime::currentDateTime();
 }
 
 AbstractAspectPrivate::~AbstractAspectPrivate() {
-	for(auto* child : m_children)
+	for (auto* child : m_children)
 		delete child;
 }
 
 void AbstractAspectPrivate::insertChild(int index, AbstractAspect* child) {
 	m_children.insert(index, child);
 
 	// Always remove from any previous parent before adding to a new one!
 	// Can't handle this case here since two undo commands have to be created.
 	Q_ASSERT(child->parentAspect() == nullptr);
 	child->setParentAspect(q);
 	q->connectChild(child);
 }
 
 int AbstractAspectPrivate::indexOfChild(const AbstractAspect* child) const {
 	for(int i=0; i<m_children.size(); ++i)
 		if(m_children.at(i) == child) return i;
 
 	return -1;
 }
 
 int AbstractAspectPrivate::removeChild(AbstractAspect* child) {
 	int index = indexOfChild(child);
 	Q_ASSERT(index != -1);
 	m_children.removeAll(child);
 	QObject::disconnect(child, nullptr, q, nullptr);
 	child->setParentAspect(nullptr);
 	return index;
 }
diff --git a/src/backend/core/AbstractColumn.cpp b/src/backend/core/AbstractColumn.cpp
index 0934c06ab..98f618f18 100644
--- a/src/backend/core/AbstractColumn.cpp
+++ b/src/backend/core/AbstractColumn.cpp
@@ -1,720 +1,720 @@
 /***************************************************************************
     File                 : AbstractColumn.cpp
     Project              : LabPlot
     Description          : Interface definition for data with column logic
     --------------------------------------------------------------------
     Copyright            : (C) 2007,2008 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2017 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 "backend/core/AbstractColumn.h"
 #include "backend/core/AbstractColumnPrivate.h"
 #include "backend/core/abstractcolumncommands.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/SignallingUndoCommand.h"
 
 #include <QDateTime>
 #include <QIcon>
 #include <KLocalizedString>
 
 #include <cmath>
 
 /**
  * \class AbstractColumn
  * \brief Interface definition for data with column logic
  *
  * This is an abstract base class for column-based data,
  * i.e. mathematically a vector or technically a 1D array or list.
  * It only defines the interface but has no data members itself.
  *
  * Classes derived from this are typically table columns or outputs
  * of filters which can be chained between table columns and plots.
  * From the point of view of the plot functions there will be no difference
  * between a table column and a filter output since both use this interface.
  *
  * Classes derived from this will either store a
  * vector with entries of one certain data type, e.g. double, QString,
  * QDateTime, or generate such values on demand. To determine the data
  * type of a class derived from this, use the columnMode() function.
  * AbstractColumn defines all access functions for all supported data
  * types but only those corresponding to the return value of columnMode()
  * will return a meaningful value. Calling functions not belonging to
  * the data type of the column is safe, but will do nothing (writing
  * function) or return some default value (reading functions).
  *
  * This class also defines all signals which indicate a data change.
  * Any class whose output values are subject to change over time must emit
  * the according signals. These signals notify any object working with the
  * column before and after a change of the column.
  * In some cases it will be necessary for a class using
  * the column to connect aboutToBeDestroyed(), to react
  * to a column's deletion, e.g. a filter's reaction to a
  * table deletion.
  *
  * All writing functions have a "do nothing" standard implementation to
  * make deriving a read-only class very easy without bothering about the
  * writing interface.
  */
 
 /**
  * \brief Ctor
  *
  * \param name the column name (= aspect name)
  */
 AbstractColumn::AbstractColumn(const QString &name) : AbstractAspect(name),
 	d( new AbstractColumnPrivate(this) ) {
 }
 
 AbstractColumn::~AbstractColumn() {
 	emit aboutToBeDestroyed(this);
 	delete d;
 }
 
 QStringList AbstractColumn::dateFormats() {
 	QStringList dates;
 	dates << "yyyy-MM-dd";
 	dates << "yyyy/MM/dd";
 	dates << "dd/MM/yyyy";
 	dates << "dd/MM/yy";
 	dates << "dd.MM.yyyy";
 	dates << "dd.MM.yy";
 	dates << "MM/yyyy";
 	dates << "dd.MM.";
 	dates << "yyyyMMdd";
 
 	return dates;
 }
 
 QStringList AbstractColumn::timeFormats() {
 	QStringList times;
 	times << "hh";
 	times << "hh ap";
 	times << "hh:mm";
 	times << "hh:mm ap";
 	times << "hh:mm:ss";
 	times << "hh:mm:ss.zzz";
 	times << "hh:mm:ss:zzz";
 	times << "mm:ss.zzz";
 	times << "hhmmss";
 
 	return times;
 }
 
 QStringList AbstractColumn::dateTimeFormats() {
 	QStringList dateTimes;
 
 	// any combination of date and times
 	for (const auto& d : dateFormats())
 		dateTimes << d;
 	for (const auto& t : timeFormats())
 		dateTimes << t;
 	for (const auto& d : dateFormats())
 		for (const auto& t : timeFormats())
 			dateTimes << d + ' ' + t;
 
 	return dateTimes;
 }
 
 /**
  * \brief Convenience method for mode-dependent icon
  */
 QIcon AbstractColumn::iconForMode(ColumnMode mode) {
 	switch (mode) {
 	case AbstractColumn::Numeric:
 	case AbstractColumn::Integer:
 		break;
 	case AbstractColumn::Text:
 		return QIcon::fromTheme("draw-text");
 	case AbstractColumn::DateTime:
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 		return QIcon::fromTheme("chronometer");
 	}
 
 	return QIcon::fromTheme("x-shape-text");
 }
 
 /**
  * \fn bool AbstractColumn::isReadOnly() const
  * \brief Return whether the object is read-only
  */
 
 /**
  * \fn AbstractColumn::ColumnMode AbstractColumn::columnMode() const
  * \brief Return the column mode
  *
  * This function is most used by tables but can also be used
  * by plots. The column mode specifies how to interpret
  * the values in the column additional to the data type.
  */
 
 /**
  * \brief Set the column mode
  *
  * This sets the column mode and, if
  * necessary, converts it to another datatype.
  */
 void AbstractColumn::setColumnMode(AbstractColumn::ColumnMode) {}
 
 /**
  * \brief Copy another column of the same type
  *
  * This function will return false if the data type
  * of 'other' is not the same as the type of 'this'.
  * Use a filter to convert a column to another type.
  */
 bool AbstractColumn::copy(const AbstractColumn *other) {
 	Q_UNUSED(other)
 	return false;
 }
 
 /**
  * \brief Copies part of another column of the same type
  *
  * This function will return false if the data type
  * of 'other' is not the same as the type of 'this'.
  * \param source pointer to the column to copy
  * \param source_start first row to copy in the column to copy
  * \param destination_start first row to copy in
  * \param num_rows the number of rows to copy
  */
 bool AbstractColumn::copy(const AbstractColumn *source, int source_start, int destination_start, int num_rows) {
 	Q_UNUSED(source)
 	Q_UNUSED(source_start)
 	Q_UNUSED(destination_start)
 	Q_UNUSED(num_rows)
 	return false;
 }
 
 /**
  * \fn int AbstractColumn::rowCount() const
  * \brief Return the data vector size
  */
 
 /**
  * \brief Insert some empty (or initialized with invalid values) rows
  */
 void AbstractColumn::insertRows(int before, int count) {
 	beginMacro( i18np("%1: insert 1 row", "%1: insert %2 rows", name(), count) );
 	exec(new SignallingUndoCommand("pre-signal", this, "rowsAboutToBeInserted", "rowsRemoved",
 	                               Q_ARG(const AbstractColumn*,this), Q_ARG(int,before), Q_ARG(int,count)));
 
 	handleRowInsertion(before, count);
 
 	exec(new SignallingUndoCommand("post-signal", this, "rowsInserted", "rowsAboutToBeRemoved",
 	                               Q_ARG(const AbstractColumn*,this), Q_ARG(int,before), Q_ARG(int,count)));
 	endMacro();
 }
 
 void AbstractColumn::handleRowInsertion(int before, int count) {
 	exec(new AbstractColumnInsertRowsCmd(this, before, count));
 }
 
 /**
  * \brief Remove 'count' rows starting from row 'first'
  */
 void AbstractColumn::removeRows(int first, int count) {
 	beginMacro( i18np("%1: remove 1 row", "%1: remove %2 rows", name(), count) );
 	exec(new SignallingUndoCommand("change signal", this, "rowsAboutToBeRemoved", "rowsInserted",
 	                               Q_ARG(const AbstractColumn*,this), Q_ARG(int,first), Q_ARG(int,count)));
 
 	handleRowRemoval(first, count);
 
 	exec(new SignallingUndoCommand("change signal", this, "rowsRemoved", "rowsAboutToBeInserted",
 	                               Q_ARG(const AbstractColumn*,this), Q_ARG(int,first), Q_ARG(int,count)));
 	endMacro();
 }
 
 void AbstractColumn::handleRowRemoval(int first, int count) {
 	exec(new AbstractColumnRemoveRowsCmd(this, first, count));
 }
 
 /**
  * \fn AbstractColumn::PlotDesignation AbstractColumn::plotDesignation() const
  * \brief Return the column plot designation
  */
 
 /**
  * \brief Set the column plot designation
  */
 void AbstractColumn::setPlotDesignation(AbstractColumn::PlotDesignation pd) {
 	Q_UNUSED(pd)
 }
 
 bool AbstractColumn::isNumeric() const {
 	const AbstractColumn::ColumnMode mode = columnMode();
 	return (mode == AbstractColumn::Numeric || mode == AbstractColumn::Integer);
 }
 
 bool AbstractColumn::isPlottable() const {
 	const AbstractColumn::ColumnMode mode = columnMode();
 	return (mode == AbstractColumn::Numeric || mode == AbstractColumn::Integer || mode == AbstractColumn::DateTime);
 }
 
 /**
  * \brief Clear the whole column
  */
 void AbstractColumn::clear() {}
 
 /**
  * \brief Convenience method for mode-independent testing of validity
  */
 bool AbstractColumn::isValid(int row) const {
 	switch (columnMode()) {
 	case AbstractColumn::Numeric:
 		return !std::isnan(valueAt(row));
 	case AbstractColumn::Integer:	// there is no invalid integer
 		return true;
 	case AbstractColumn::Text:
 		return !textAt(row).isNull();
 	case AbstractColumn::DateTime:
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 		return dateTimeAt(row).isValid();
 	}
 
 	return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name IntervalAttribute related functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Return whether a certain row is masked
  */
 bool AbstractColumn::isMasked(int row) const {
 	return d->m_masking.isSet(row);
 }
 
 /**
  * \brief Return whether a certain interval of rows is fully masked
  */
 bool AbstractColumn::isMasked(const Interval<int>& i) const {
 	return d->m_masking.isSet(i);
 }
 
 /**
  * \brief Return all intervals of masked rows
  */
 QVector< Interval<int> > AbstractColumn::maskedIntervals() const {
 	return d->m_masking.intervals();
 }
 
 /**
  * \brief Clear all masking information
  */
 void AbstractColumn::clearMasks() {
 	exec(new AbstractColumnClearMasksCmd(d),
 	     "maskingAboutToChange", "maskingChanged", Q_ARG(const AbstractColumn*,this));
 }
 
 /**
  * \brief Set an interval masked
  *
  * \param i the interval
  * \param mask true: mask, false: unmask
  */
 void AbstractColumn::setMasked(const Interval<int>& i, bool mask) {
 	exec(new AbstractColumnSetMaskedCmd(d, i, mask),
 	     "maskingAboutToChange", "maskingChanged", Q_ARG(const AbstractColumn*,this));
 }
 
 /**
  * \brief Overloaded function for convenience
  */
 void AbstractColumn::setMasked(int row, bool mask) {
 	setMasked(Interval<int>(row,row), mask);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name Formula related functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Return the formula associated with row 'row'
  */
 QString AbstractColumn::formula(int row) const {
 	Q_UNUSED(row);
 	return QString();
 }
 
 /**
  * \brief Return the intervals that have associated formulas
  *
  * This can be used to make a list of formulas with their intervals.
  * Here is some example code:
  *
  * \code
  * QStringList list;
  * QVector< Interval<int> > intervals = my_column.formulaIntervals();
  * foreach(Interval<int> interval, intervals)
  * 	list << QString(interval.toString() + ": " + my_column.formula(interval.start()));
  * \endcode
  */
 QVector< Interval<int> > AbstractColumn::formulaIntervals() const {
 	return QVector< Interval<int> >();
 }
 
 /**
  * \brief Set a formula string for an interval of rows
  */
 void AbstractColumn::setFormula(const Interval<int>& i, const QString& formula) {
 	Q_UNUSED(i) Q_UNUSED(formula)
 }
 
 /**
  * \brief Overloaded function for convenience
  */
 void AbstractColumn::setFormula(int row, const QString& formula) {
 	Q_UNUSED(row) Q_UNUSED(formula)
 }
 
 /**
  * \brief Clear all formulas
  */
 void AbstractColumn::clearFormulas() {};
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name type specific functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Return the content of row 'row'.
  *
  * Use this only when columnMode() is Text
  */
 QString AbstractColumn::textAt(int row) const {
 	Q_UNUSED(row);
 	return "";
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Text
  */
 void AbstractColumn::setTextAt(int row, const QString& new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 }
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Text
  */
 void AbstractColumn::replaceTexts(int first, const QVector<QString>& new_values) {
 	Q_UNUSED(first) Q_UNUSED(new_values)
 };
 
 /**
  * \brief Return the date part of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QDate AbstractColumn::dateAt(int row) const {
 	Q_UNUSED(row);
 	return QDate{};
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void AbstractColumn::setDateAt(int row, QDate new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 };
 
 /**
  * \brief Return the time part of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QTime AbstractColumn::timeAt(int row) const {
 	Q_UNUSED(row);
 	return QTime{};
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void AbstractColumn::setTimeAt(int row, QTime new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 }
 
 /**
  * \brief Return the QDateTime in row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QDateTime AbstractColumn::dateTimeAt(int row) const {
 	Q_UNUSED(row);
 	return QDateTime();
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void AbstractColumn::setDateTimeAt(int row, const QDateTime& new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 };
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void AbstractColumn::replaceDateTimes(int first, const QVector<QDateTime>& new_values) {
 	Q_UNUSED(first) Q_UNUSED(new_values)
 };
 
 /**
  * \brief Return the double value in row 'row'
  *
  * Use this only when columnMode() is Numeric
  */
 double AbstractColumn::valueAt(int row) const {
 	Q_UNUSED(row);
 	return NAN;
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Numeric
  */
 void AbstractColumn::setValueAt(int row, const double new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 };
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Numeric
  */
 void AbstractColumn::replaceValues(int first, const QVector<double>& new_values) {
 	Q_UNUSED(first) Q_UNUSED(new_values)
 }
 
 /**
  * \brief Return the integer value in row 'row'
  *
  * Use this only when columnMode() is Integer
  */
 int AbstractColumn::integerAt(int row) const {
 	Q_UNUSED(row);
 	return 42;
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Integer
  */
 void AbstractColumn::setIntegerAt(int row, const int new_value) {
 	Q_UNUSED(row) Q_UNUSED(new_value)
 };
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Integer
  */
 void AbstractColumn::replaceInteger(int first, const QVector<int>& new_values) {
 	Q_UNUSED(first) Q_UNUSED(new_values)
 }
 
 /**********************************************************************/
 double AbstractColumn::minimum(int count) const {
 	Q_UNUSED(count);
 	return -INFINITY;
 }
 
 double AbstractColumn::maximum(int count) const {
 	Q_UNUSED(count);
 	return INFINITY;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \fn void AbstractColumn::plotDesignationAboutToChange(const AbstractColumn *source)
  * \brief Column plot designation will be changed
  *
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::plotDesignationChanged(const AbstractColumn *source)
  * \brief Column plot designation changed
  *
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::modeAboutToChange(const AbstractColumn *source)
  * \brief Column mode (possibly also the data type) will be changed
  *
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::modeChanged(const AbstractColumn *source)
  * \brief Column mode (possibly also the data type) changed
  *
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::dataAboutToChange(const AbstractColumn *source)
  * \brief Data of the column will be changed
  *
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::dataChanged(const AbstractColumn *source)
  * \brief Data of the column has changed
  *
  * Important: When data has changed also the number
  * of rows in the column may have changed without
  * any other signal emission.
  * 'source' is always the this pointer of the column that
  * emitted this signal. This way it's easier to use
  * one handler for lots of columns.
  */
 
 /**
  * \fn void AbstractColumn::rowsAboutToBeInserted(const AbstractColumn *source, int before, int count)
  * \brief Rows will be inserted
  *
  *	\param source the column that emitted the signal
  *	\param before the row to insert before
  *	\param count the number of rows to be inserted
  */
 
 /**
  * \fn void AbstractColumn::rowsInserted(const AbstractColumn *source, int before, int count)
  * \brief Rows have been inserted
  *
  *	\param source the column that emitted the signal
  *	\param before the row to insert before
  *	\param count the number of rows to be inserted
  */
 
 /**
  * \fn void AbstractColumn::rowsAboutToBeRemoved(const AbstractColumn *source, int first, int count)
  * \brief Rows will be deleted
  *
  *	\param source the column that emitted the signal
  *	\param first the first row to be deleted
  *	\param count the number of rows to be deleted
  */
 
 /**
  * \fn void AbstractColumn::rowsRemoved(const AbstractColumn *source, int first, int count)
  * \brief Rows have been deleted
  *
  *	\param source the column that emitted the signal
  *	\param first the first row that was deleted
  *	\param count the number of deleted rows
  */
 
 /**
  * \fn void AbstractColumn::maskingAboutToChange(const AbstractColumn *source)
  * \brief Rows are about to be masked or unmasked
  */
 
 /**
  * \fn void AbstractColumn::maskingChanged(const AbstractColumn *source)
  * \brief Rows have been masked or unmasked
  */
 
 /**
  * \fn void AbstractColumn::aboutToBeDestroyed(const AbstractColumn *source)
  * \brief Emitted shortl before this column is deleted
  *
  * \param source the object emitting this signal
  *
  * This is needed by AbstractFilter.
  */
 
 /**
  * \brief Read XML mask element
  */
 bool AbstractColumn::XmlReadMask(XmlStreamReader *reader) {
 	Q_ASSERT(reader->isStartElement() && reader->name() == "mask");
 
 	bool ok1, ok2;
 	int start, end;
 	start = reader->readAttributeInt("start_row", &ok1);
 	end = reader->readAttributeInt("end_row", &ok2);
 	if(!ok1 || !ok2) {
 		reader->raiseError(i18n("invalid or missing start or end row"));
 		return false;
 	}
 	setMasked(Interval<int>(start,end));
 	if (!reader->skipToEndElement()) return false;
 
 	return true;
 }
 
 /**
  * \brief Write XML mask element
  */
 void AbstractColumn::XmlWriteMask(QXmlStreamWriter *writer) const {
-	for (const auto& interval: maskedIntervals()) {
+	for (const auto& interval : maskedIntervals()) {
 		writer->writeStartElement("mask");
 		writer->writeAttribute("start_row", QString::number(interval.start()));
 		writer->writeAttribute("end_row", QString::number(interval.end()));
 		writer->writeEndElement();
 	}
 }
diff --git a/src/backend/core/column/Column.cpp b/src/backend/core/column/Column.cpp
index 52f05a804..3c8099bf5 100644
--- a/src/backend/core/column/Column.cpp
+++ b/src/backend/core/column/Column.cpp
@@ -1,1234 +1,1234 @@
 /***************************************************************************
     File                 : Column.cpp
     Project              : LabPlot
     Description          : Aspect that manages a column
     --------------------------------------------------------------------
     Copyright            : (C) 2007-2009 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2013-2017 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2017 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 "backend/core/column/Column.h"
 #include "backend/core/column/ColumnPrivate.h"
 #include "backend/core/column/ColumnStringIO.h"
 #include "backend/core/column/columncommands.h"
 #include "backend/core/Project.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/core/datatypes/String2DateTimeFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/plots/cartesian/XYAnalysisCurve.h"
 
 extern "C" {
 #include <gsl/gsl_sort.h>
 }
 
 #include <QFont>
 #include <QFontMetrics>
 #include <QIcon>
 #include <QMenu>
 #include <QThreadPool>
 
 #include <KLocalizedString>
 
 /**
  * \class Column
  * \brief Aspect that manages a column
  *
  * This class represents a column, i.e., (mathematically) a 1D vector of
  * values with a header. It provides a public reading and (undo aware) writing
  * interface as defined in AbstractColumn. A column
  * can have one of currently three data types: double, QString, or
  * QDateTime. The string representation of the values can differ depending
  * on the mode of the column.
  *
  * Column inherits from AbstractAspect and is intended to be a child
  * of the corresponding Spreadsheet in the aspect hierarchy. Columns don't
  * have a view as they are intended to be displayed inside a spreadsheet.
  */
 
 Column::Column(const QString& name, AbstractColumn::ColumnMode mode)
 	: AbstractColumn(name), d(new ColumnPrivate(this, mode)) {
 	init();
 }
 
 /**
  * \brief Common part of ctors
  */
 void Column::init() {
 	m_string_io = new ColumnStringIO(this);
 	d->inputFilter()->input(0, m_string_io);
 	d->outputFilter()->input(0, this);
 	d->inputFilter()->setHidden(true);
 	d->outputFilter()->setHidden(true);
 	addChild(d->inputFilter());
 	addChild(d->outputFilter());
 	m_suppressDataChangedSignal = false;
 
 	m_usedInActionGroup = new QActionGroup(this);
 	connect(m_usedInActionGroup, &QActionGroup::triggered, this, &Column::navigateTo);
 }
 
 Column::~Column() {
 	delete m_string_io;
 	delete d;
 }
 
 QMenu* Column::createContextMenu() {
 	QMenu* menu = AbstractAspect::createContextMenu();
 	QAction* firstAction = menu->actions().at(1);
 
 	//add actions available in SpreadsheetView
 	emit requestProjectContextMenu(menu);
 
 	//"Used in" menu containing all curves where the column is used
 	QMenu* usedInMenu = new QMenu(i18n("Used in"));
 	usedInMenu->setIcon(QIcon::fromTheme("go-next-view"));
 
 	//remove previously added actions
-	for (auto* action: m_usedInActionGroup->actions())
+	for (auto* action : m_usedInActionGroup->actions())
 		m_usedInActionGroup->removeAction(action);
 
 	//add curves where the column is currently in use
 	QVector<XYCurve*> curves = project()->children<XYCurve>(AbstractAspect::Recursive);
-	for (const auto* curve: curves) {
+	for (const auto* curve : curves) {
 		bool used = false;
 
 		const XYAnalysisCurve* analysisCurve = dynamic_cast<const XYAnalysisCurve*>(curve);
 		if (analysisCurve) {
 			if (analysisCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet && (analysisCurve->xDataColumn() == this || analysisCurve->yDataColumn() == this || analysisCurve->y2DataColumn() == this) )
 				used = true;
 		} else {
 			if (curve->xColumn() == this || curve->yColumn() == this)
 				used = true;
 		}
 
 		if (used) {
 			QAction* action = new QAction(curve->icon(), curve->name(), m_usedInActionGroup);
 			action->setData(curve->path());
 			usedInMenu->addAction(action);
 		}
 	}
 
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, usedInMenu);
 	menu->insertSeparator(firstAction);
 
 	return menu;
 }
 
 void Column::navigateTo(QAction* action) {
 	project()->navigateTo(action->data().toString());
 }
 
 /*!
  *
  */
 void Column::setSuppressDataChangedSignal(bool b) {
 	m_suppressDataChangedSignal = b;
 }
 
 /**
  * \brief Set the column mode
  *
  * This sets the column mode and, if
  * necessary, converts it to another datatype.
  */
 void Column::setColumnMode(AbstractColumn::ColumnMode mode) {
 	if (mode == columnMode())
 		return;
 
 	DEBUG("Column::setColumnMode()");
 	beginMacro(i18n("%1: change column type", name()));
 
 	auto* old_input_filter = d->inputFilter();
 	auto* old_output_filter = d->outputFilter();
 	exec(new ColumnSetModeCmd(d, mode));
 
 	if (d->inputFilter() != old_input_filter) {
 		removeChild(old_input_filter);
 		addChild(d->inputFilter());
 		d->inputFilter()->input(0, m_string_io);
 	}
 	if (d->outputFilter() != old_output_filter) {
 		removeChild(old_output_filter);
 		addChild(d->outputFilter());
 		d->outputFilter()->input(0, this);
 	}
 
 	endMacro();
 	DEBUG("Column::setColumnMode() DONE");
 }
 
 void Column::setColumnModeFast(AbstractColumn::ColumnMode mode) {
 	if (mode == columnMode())
 		return;
 
 	auto* old_input_filter = d->inputFilter();
 	auto* old_output_filter = d->outputFilter();
 	exec(new ColumnSetModeCmd(d, mode));
 
 	if (d->inputFilter() != old_input_filter) {
 		removeChild(old_input_filter);
 		addChildFast(d->inputFilter());
 		d->inputFilter()->input(0, m_string_io);
 	}
 	if (d->outputFilter() != old_output_filter) {
 		removeChild(old_output_filter);
 		addChildFast(d->outputFilter());
 		d->outputFilter()->input(0, this);
 	}
 }
 
 /**
  * \brief Copy another column of the same type
  *
  * This function will return false if the data type
  * of 'other' is not the same as the type of 'this'.
  * Use a filter to convert a column to another type.
  */
 bool Column::copy(const AbstractColumn* other) {
 	Q_CHECK_PTR(other);
 	if (other->columnMode() != columnMode()) return false;
 	exec(new ColumnFullCopyCmd(d, other));
 	return true;
 }
 
 /**
  * \brief Copies a part of another column of the same type
  *
  * This function will return false if the data type
  * of 'other' is not the same as the type of 'this'.
  * \param other pointer to the column to copy
  * \param src_start first row to copy in the column to copy
  * \param dest_start first row to copy in
  * \param num_rows the number of rows to copy
  */
 bool Column::copy(const AbstractColumn* source, int source_start, int dest_start, int num_rows) {
 	Q_CHECK_PTR(source);
 	if (source->columnMode() != columnMode()) return false;
 	exec(new ColumnPartialCopyCmd(d, source, source_start, dest_start, num_rows));
 	return true;
 }
 
 /**
  * \brief Insert some empty (or initialized with zero) rows
  */
 void Column::handleRowInsertion(int before, int count) {
 	AbstractColumn::handleRowInsertion(before, count);
 	exec(new ColumnInsertRowsCmd(d, before, count));
 	if (!m_suppressDataChangedSignal)
 		emit dataChanged(this);
 
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 }
 
 /**
  * \brief Remove 'count' rows starting from row 'first'
  */
 void Column::handleRowRemoval(int first, int count) {
 	AbstractColumn::handleRowRemoval(first, count);
 	exec(new ColumnRemoveRowsCmd(d, first, count));
 	if (!m_suppressDataChangedSignal)
 		emit dataChanged(this);
 
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 }
 
 /**
  * \brief Set the column plot designation
  */
 void Column::setPlotDesignation(AbstractColumn::PlotDesignation pd) {
 	if (pd != plotDesignation())
 		exec(new ColumnSetPlotDesignationCmd(d, pd));
 }
 
 /**
  * \brief Get width
  */
 int Column::width() const {
 	return d->width();
 }
 
 /**
  * \brief Set width
  */
 void Column::setWidth(int value) {
 	d->setWidth(value);
 }
 
 /**
  * \brief Clear the whole column
  */
 void Column::clear() {
 	exec(new ColumnClearCmd(d));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
 //! \name Formula related functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * \brief Returns the formula used to generate column values
  */
 QString Column:: formula() const {
 	return d->formula();
 }
 
 const QStringList& Column::formulaVariableNames() const {
 	return d->formulaVariableNames();
 }
 
 const QStringList& Column::formulaVariableColumnPathes() const {
 	return d->formulaVariableColumnPathes();
 }
 
 /**
  * \brief Sets the formula used to generate column values
  */
 void Column::setFormula(const QString& formula, const QStringList& variableNames, const QStringList& columnPathes) {
 	exec(new ColumnSetGlobalFormulaCmd(d, formula, variableNames, columnPathes));
 }
 
 /**
  * \brief Set a formula string for an interval of rows
  */
 void Column::setFormula(const Interval<int>& i, const QString& formula) {
 	exec(new ColumnSetFormulaCmd(d, i, formula));
 }
 
 /**
  * \brief Overloaded function for convenience
  */
 void Column::setFormula(int row, const QString& formula) {
 	setFormula(Interval<int>(row, row), formula);
 }
 
 /**
  * \brief Clear all formulas
  */
 void Column::clearFormulas() {
 	exec(new ColumnClearFormulasCmd(d));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
 //! \name type specific functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Text
  */
 void Column::setTextAt(int row, const QString& new_value) {
 	DEBUG("Column::setTextAt()");
 	d->statisticsAvailable = false;;
 	exec(new ColumnSetTextCmd(d, row, new_value));
 }
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Text
  */
 void Column::replaceTexts(int first, const QVector<QString>& new_values) {
 	DEBUG("Column::replaceTexts()");
 	if (!new_values.isEmpty()) { //TODO: do we really need this check?
 		d->statisticsAvailable = false;;
 		exec(new ColumnReplaceTextsCmd(d, first, new_values));
 	}
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void Column::setDateAt(int row, QDate new_value) {
 	d->statisticsAvailable = false;;
 	setDateTimeAt(row, QDateTime(new_value, timeAt(row)));
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void Column::setTimeAt(int row, QTime new_value) {
 	d->statisticsAvailable = false;;
 	setDateTimeAt(row, QDateTime(dateAt(row), new_value));
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void Column::setDateTimeAt(int row, const QDateTime& new_value) {
 	d->statisticsAvailable = false;;
 	exec(new ColumnSetDateTimeCmd(d, row, new_value));
 }
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 void Column::replaceDateTimes(int first, const QVector<QDateTime>& new_values) {
 	if (!new_values.isEmpty()) {
 		d->statisticsAvailable = false;;
 		exec(new ColumnReplaceDateTimesCmd(d, first, new_values));
 	}
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Numeric
  */
 void Column::setValueAt(int row, const double new_value) {
 // 	DEBUG("Column::setValueAt()");
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 	exec(new ColumnSetValueCmd(d, row, new_value));
 }
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Numeric
  */
 void Column::replaceValues(int first, const QVector<double>& new_values) {
 	DEBUG("Column::replaceValues()");
 	if (!new_values.isEmpty()) {
 		d->statisticsAvailable = false;;
 		d->hasValuesAvailable = false;
 		exec(new ColumnReplaceValuesCmd(d, first, new_values));
 	}
 }
 
 /**
  * \brief Set the content of row 'row'
  *
  * Use this only when columnMode() is Integer
  */
 void Column::setIntegerAt(int row, const int new_value) {
 	DEBUG("Column::setIntegerAt()");
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 	exec(new ColumnSetIntegerCmd(d, row, new_value));
 }
 
 /**
  * \brief Replace a range of values
  *
  * Use this only when columnMode() is Integer
  */
 void Column::replaceInteger(int first, const QVector<int>& new_values) {
 	DEBUG("Column::replaceInteger()");
 	if (!new_values.isEmpty()) {
 		d->statisticsAvailable = false;;
 		d->hasValuesAvailable = false;
 		exec(new ColumnReplaceIntegersCmd(d, first, new_values));
 	}
 }
 
 const Column::ColumnStatistics& Column::statistics() const {
 	if (!d->statisticsAvailable)
 		calculateStatistics();
 
 	return d->statistics;
 }
 
 void Column::calculateStatistics() const {
 	d->statistics = ColumnStatistics();
 	ColumnStatistics& statistics = d->statistics;
 
 	// TODO: support other data types?
 	QVector<double>* rowValues = reinterpret_cast<QVector<double>*>(data());
 
 	size_t notNanCount = 0;
 	double val;
 	double columnSum = 0.0;
 	double columnProduct = 1.0;
 	double columnSumNeg = 0.0;
 	double columnSumSquare = 0.0;
 	statistics.minimum = INFINITY;
 	statistics.maximum = -INFINITY;
 	QMap<double, int> frequencyOfValues;
 	QVector<double> rowData;
 	rowData.reserve(rowValues->size());
 	for (int row = 0; row < rowValues->size(); ++row) {
 		val = rowValues->value(row);
 		if (std::isnan(val) || isMasked(row))
 			continue;
 
 		if (val < statistics.minimum)
 			statistics.minimum = val;
 		if (val > statistics.maximum)
 			statistics.maximum = val;
 		columnSum+= val;
 		columnSumNeg += (1.0 / val);
 		columnSumSquare += pow(val, 2.0);
 		columnProduct *= val;
 		if (frequencyOfValues.contains(val))
 			frequencyOfValues.operator [](val)++;
 		else
 			frequencyOfValues.insert(val, 1);
 		++notNanCount;
 		rowData.push_back(val);
 	}
 
 	if (notNanCount == 0) {
 		d->statisticsAvailable = true;
 		return;
 	}
 
 	if (rowData.size() < rowValues->size())
 		rowData.squeeze();
 
 	statistics.arithmeticMean = columnSum / notNanCount;
 	statistics.geometricMean = pow(columnProduct, 1.0 / notNanCount);
 	statistics.harmonicMean = notNanCount / columnSumNeg;
 	statistics.contraharmonicMean = columnSumSquare / columnSum;
 
 	double columnSumVariance = 0;
 	double columnSumMeanDeviation = 0.0;
 	double columnSumMedianDeviation = 0.0;
 	double sumForCentralMoment_r3 = 0.0;
 	double sumForCentralMoment_r4 = 0.0;
 
 	gsl_sort(rowData.data(), 1, notNanCount);
 	statistics.median = (notNanCount%2) ? rowData.at((int)((notNanCount-1)/2)) :
 	                    (rowData.at((int)((notNanCount-1)/2)) + rowData.at((int)(notNanCount/2)))/2.0;
 	QVector<double> absoluteMedianList;
 	absoluteMedianList.reserve((int)notNanCount);
 	absoluteMedianList.resize((int)notNanCount);
 
 	int idx = 0;
 	for(int row = 0; row < rowValues->size(); ++row) {
 		val = rowValues->value(row);
 		if (std::isnan(val) || isMasked(row) )
 			continue;
 		columnSumVariance += pow(val - statistics.arithmeticMean, 2.0);
 
 		sumForCentralMoment_r3 += pow(val - statistics.arithmeticMean, 3.0);
 		sumForCentralMoment_r4 += pow(val - statistics.arithmeticMean, 4.0);
 		columnSumMeanDeviation += fabs( val - statistics.arithmeticMean );
 
 		absoluteMedianList[idx] = fabs(val - statistics.median);
 		columnSumMedianDeviation += absoluteMedianList[idx];
 		idx++;
 	}
 
 	statistics.meanDeviationAroundMedian = columnSumMedianDeviation / notNanCount;
 	statistics.medianDeviation = (notNanCount%2) ? absoluteMedianList.at((int)((notNanCount-1)/2)) :
 	                             (absoluteMedianList.at((int)((notNanCount-1)/2)) + absoluteMedianList.at((int)(notNanCount/2)))/2.0;
 
 	const double centralMoment_r3 = sumForCentralMoment_r3 / notNanCount;
 	const double centralMoment_r4 = sumForCentralMoment_r4 / notNanCount;
 
 	statistics.variance = columnSumVariance / notNanCount;
 	statistics.standardDeviation = sqrt(statistics.variance);
 	statistics.skewness = centralMoment_r3 / pow(statistics.standardDeviation, 3.0);
 	statistics.kurtosis = (centralMoment_r4 / pow(statistics.standardDeviation, 4.0)) - 3.0;
 	statistics.meanDeviation = columnSumMeanDeviation / notNanCount;
 
 	double entropy = 0.0;
-	for (const auto& v: frequencyOfValues) {
+	for (const auto& v : frequencyOfValues) {
 		const double frequencyNorm = static_cast<double>(v) / notNanCount;
 		entropy += (frequencyNorm * log2(frequencyNorm));
 	}
 
 	statistics.entropy = -entropy;
 	d->statisticsAvailable = true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 void* Column::data() const {
 	return d->data();
 }
 
 /*!
  * return \c true if the column has numeric values, \false otherwise.
  */
 bool Column::hasValues() const {
 	if (columnMode() == AbstractColumn::Numeric) {
 		if (d->hasValuesAvailable) {
 			return d->hasValues;
 		} else {
 			bool foundValues = false;
 			for (int row = 0; row < rowCount(); ++row) {
 				if (!std::isnan(valueAt(row))) {
 					foundValues = true;
 					break;
 				}
 			}
 
 			d->hasValues = foundValues;
 			d->hasValuesAvailable = true;
 			return d->hasValues;
 		}
 	} else if (columnMode() == AbstractColumn::Integer)
 		return true; //integer column has always valid values
 	else
 		return false; //non-numerical column
 }
 
 //TODO: support all data types
 /**
  * \brief Return the content of row 'row'.
  *
  * Use this only when columnMode() is Text
  */
 QString Column::textAt(int row) const {
 	return d->textAt(row);
 }
 
 /**
  * \brief Return the date part of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QDate Column::dateAt(int row) const {
 	return d->dateAt(row);
 }
 
 /**
  * \brief Return the time part of row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QTime Column::timeAt(int row) const {
 	return d->timeAt(row);
 }
 
 /**
  * \brief Return the QDateTime in row 'row'
  *
  * Use this only when columnMode() is DateTime, Month or Day
  */
 QDateTime Column::dateTimeAt(int row) const {
 	return d->dateTimeAt(row);
 }
 
 /**
  * \brief Return the double value in row 'row'
  */
 double Column::valueAt(int row) const {
 	return d->valueAt(row);
 }
 
 /**
  * \brief Return the int value in row 'row'
  */
 int Column::integerAt(int row) const {
 	return d->integerAt(row);
 }
 
 /*
  * call this function if the data of the column was changed directly via the data()-pointer
  * and not via the setValueAt() in order to emit the dataChanged-signal.
  * This is used e.g. in \c XYFitCurvePrivate::recalculate()
  */
 void Column::setChanged() {
 	if (!m_suppressDataChangedSignal)
 		emit dataChanged(this);
 
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Return an icon to be used for decorating the views and spreadsheet column headers
  */
 QIcon Column::icon() const {
 	return iconForMode(columnMode());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 //! \name serialize/deserialize
 //@{
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Save the column as XML
  */
 void Column::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("column");
 	writeBasicAttributes(writer);
 
 	writer->writeAttribute("designation", QString::number(plotDesignation()));
 	writer->writeAttribute("mode", QString::number(columnMode()));
 	writer->writeAttribute("width", QString::number(width()));
 
 	//save the formula used to generate column values, if available
 	if (!formula().isEmpty() ) {
 		writer->writeStartElement("formula");
 		writer->writeTextElement("text", formula());
 
 		writer->writeStartElement("variableNames");
-		for (const auto& name: formulaVariableNames())
+		for (const auto& name : formulaVariableNames())
 			writer->writeTextElement("name", name);
 		writer->writeEndElement();
 
 		writer->writeStartElement("columnPathes");
-		for (const auto& path: formulaVariableColumnPathes())
+		for (const auto& path : formulaVariableColumnPathes())
 			writer->writeTextElement("path", path);
 		writer->writeEndElement();
 
 		writer->writeEndElement();
 	}
 
 	writeCommentElement(writer);
 
 	writer->writeStartElement("input_filter");
 	d->inputFilter()->save(writer);
 	writer->writeEndElement();
 
 	writer->writeStartElement("output_filter");
 	d->outputFilter()->save(writer);
 	writer->writeEndElement();
 
 	XmlWriteMask(writer);
 
 	//TODO: formula in cells is not implemented yet
 	// 	QVector< Interval<int> > formulas = formulaIntervals();
 	// 	foreach(const Interval<int>& interval, formulas) {
 	// 		writer->writeStartElement("formula");
 	// 		writer->writeAttribute("start_row", QString::number(interval.start()));
 	// 		writer->writeAttribute("end_row", QString::number(interval.end()));
 	// 		writer->writeCharacters(formula(interval.start()));
 	// 		writer->writeEndElement();
 	// 	}
 
 	int i;
 	switch(columnMode()) {
 	case AbstractColumn::Numeric: {
 			const char* data = reinterpret_cast<const char*>(static_cast< QVector<double>* >(d->data())->constData());
 			size_t size = d->rowCount() * sizeof(double);
 			writer->writeCharacters(QByteArray::fromRawData(data, (int)size).toBase64());
 			break;
 		}
 	case AbstractColumn::Integer: {
 			const char* data = reinterpret_cast<const char*>(static_cast< QVector<int>* >(d->data())->constData());
 			size_t size = d->rowCount() * sizeof(int);
 			writer->writeCharacters(QByteArray::fromRawData(data, (int)size).toBase64());
 			break;
 		}
 	case AbstractColumn::Text:
 		for (i = 0; i < rowCount(); ++i) {
 			writer->writeStartElement("row");
 			writer->writeAttribute("index", QString::number(i));
 			writer->writeCharacters(textAt(i));
 			writer->writeEndElement();
 		}
 		break;
 	case AbstractColumn::DateTime:
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 		for (i = 0; i < rowCount(); ++i) {
 			writer->writeStartElement("row");
 			writer->writeAttribute("index", QString::number(i));
 			writer->writeCharacters(dateTimeAt(i).toString("yyyy-dd-MM hh:mm:ss:zzz"));
 			writer->writeEndElement();
 		}
 		break;
 	}
 
 	writer->writeEndElement(); // "column"
 }
 
 //TODO: extra header
 class DecodeColumnTask : public QRunnable {
 public:
 	DecodeColumnTask(ColumnPrivate* priv, const QString& content) {
 		m_private = priv;
 		m_content = content;
 	};
 	void run() override {
 		QByteArray bytes = QByteArray::fromBase64(m_content.toLatin1());
 		if (m_private->columnMode() == AbstractColumn::Numeric) {
 			QVector<double>* data = new QVector<double>(bytes.size()/(int)sizeof(double));
 			memcpy(data->data(), bytes.data(), bytes.size());
 			m_private->replaceData(data);
 		} else {
 			QVector<int>* data = new QVector<int>(bytes.size()/(int)sizeof(int));
 			memcpy(data->data(), bytes.data(), bytes.size());
 			m_private->replaceData(data);
 		}
 	}
 
 private:
 	ColumnPrivate* m_private;
 	QString m_content;
 };
 
 /**
  * \brief Load the column from XML
  */
 bool Column::load(XmlStreamReader* reader, bool preview) {
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs = reader->attributes();
 
 	QString str = attribs.value("designation").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("designation").toString());
 	else
 		d->setPlotDesignation( AbstractColumn::PlotDesignation(str.toInt()) );
 
 	str = attribs.value("mode").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("mode").toString());
 	else
 		setColumnModeFast( AbstractColumn::ColumnMode(str.toInt()) );
 
 	str = attribs.value("width").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("width").toString());
 	else
 		d->setWidth(str.toInt());
 
 	// read child elements
 	while (!reader->atEnd()) {
 		reader->readNext();
 
 		if (reader->isEndElement()) break;
 
 		if (reader->isStartElement()) {
 			bool ret_val = true;
 			if (reader->name() == "comment")
 				ret_val = readCommentElement(reader);
 			else if (reader->name() == "input_filter")
 				ret_val = XmlReadInputFilter(reader);
 			else if (reader->name() == "output_filter")
 				ret_val = XmlReadOutputFilter(reader);
 			else if (reader->name() == "mask")
 				ret_val = XmlReadMask(reader);
 			else if (reader->name() == "formula")
 				ret_val = XmlReadFormula(reader);
 			else if (reader->name() == "row")
 				ret_val = XmlReadRow(reader);
 			else { // unknown element
 				reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 				if (!reader->skipToEndElement()) return false;
 			}
 			if (!ret_val)
 				return false;
 		}
 		if (!preview) {
 			QString content = reader->text().toString().trimmed();
 			if (!content.isEmpty() && ( columnMode() == AbstractColumn::Numeric ||  columnMode() == AbstractColumn::Integer)) {
 				DecodeColumnTask* task = new DecodeColumnTask(d, content);
 				QThreadPool::globalInstance()->start(task);
 			}
 		}
 	}
 
 	return !reader->error();
 }
 
 /**
  * \brief Read XML input filter element
  */
 bool Column::XmlReadInputFilter(XmlStreamReader* reader) {
 	Q_ASSERT(reader->isStartElement() == true && reader->name() == "input_filter");
 	if (!reader->skipToNextTag()) return false;
 	if (!d->inputFilter()->load(reader, false)) return false;
 	if (!reader->skipToNextTag()) return false;
 	Q_ASSERT(reader->isEndElement() == true && reader->name() == "input_filter");
 	return true;
 }
 
 /**
  * \brief Read XML output filter element
  */
 bool Column::XmlReadOutputFilter(XmlStreamReader* reader) {
 	Q_ASSERT(reader->isStartElement() == true && reader->name() == "output_filter");
 	if (!reader->skipToNextTag()) return false;
 	if (!d->outputFilter()->load(reader, false)) return false;
 	if (!reader->skipToNextTag()) return false;
 	Q_ASSERT(reader->isEndElement() == true && reader->name() == "output_filter");
 	return true;
 }
 
 /**
  * \brief Read XML formula element
  */
 bool Column::XmlReadFormula(XmlStreamReader* reader) {
 	QString formula;
 	QStringList variableNames;
 	QStringList columnPathes;
 	while (reader->readNext()) {
 		if (reader->isEndElement()) break;
 
 		if (reader->name() == "text")
 			formula = reader->readElementText();
 		else if (reader->name() == "variableNames") {
 			while (reader->readNext()) {
 				if (reader->name() == "variableNames" && reader->isEndElement()) break;
 
 				if (reader->isStartElement())
 					variableNames << reader->readElementText();
 			}
 		} else if (reader->name() == "columnPathes") {
 			while (reader->readNext()) {
 				if (reader->name() == "columnPathes" && reader->isEndElement()) break;
 
 				if (reader->isStartElement())
 					columnPathes << reader->readElementText();
 			}
 		}
 	}
 	setFormula(formula, variableNames, columnPathes);
 	return true;
 }
 
 //TODO: read cell formula, not implemented yet
 // bool Column::XmlReadFormula(XmlStreamReader* reader)
 // {
 // 	Q_ASSERT(reader->isStartElement() && reader->name() == "formula");
 //
 // 	bool ok1, ok2;
 // 	int start, end;
 // 	start = reader->readAttributeInt("start_row", &ok1);
 // 	end = reader->readAttributeInt("end_row", &ok2);
 // 	if(!ok1 || !ok2)
 // 	{
 // 		reader->raiseError(i18n("invalid or missing start or end row"));
 // 		return false;
 // 	}
 // 	setFormula(Interval<int>(start,end), reader->readElementText());
 //
 // 	return true;
 // }
 
 
 /**
  * \brief Read XML row element
  */
 bool Column::XmlReadRow(XmlStreamReader* reader) {
 	Q_ASSERT(reader->isStartElement() == true && reader->name() == "row");
 
 	//	QXmlStreamAttributes attribs = reader->attributes();
 
 	bool ok;
 	int index = reader->readAttributeInt("index", &ok);
 	if (!ok) {
 		reader->raiseError(i18n("invalid or missing row index"));
 		return false;
 	}
 
 	QString str = reader->readElementText();
 	switch (columnMode()) {
 	case AbstractColumn::Numeric: {
 			double value = str.toDouble(&ok);
 			if(!ok) {
 				reader->raiseError(i18n("invalid row value"));
 				return false;
 			}
 			setValueAt(index, value);
 			break;
 		}
 	case AbstractColumn::Integer: {
 			int value = str.toInt(&ok);
 			if(!ok) {
 				reader->raiseError(i18n("invalid row value"));
 				return false;
 			}
 			setIntegerAt(index, value);
 			break;
 		}
 	case AbstractColumn::Text:
 		setTextAt(index, str);
 		break;
 
 	case AbstractColumn::DateTime:
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 		QDateTime date_time = QDateTime::fromString(str,"yyyy-dd-MM hh:mm:ss:zzz");
 		setDateTimeAt(index, date_time);
 		break;
 	}
 
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //@}
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * \brief Return whether the object is read-only
  */
 bool Column::isReadOnly() const {
 	return false;
 }
 
 /**
  * \brief Return the column mode
  *
  * This function is mostly used by spreadsheets but can also be used
  * by plots. The column mode specifies how to interpret
  * the values in the column additional to the data type.
  */
 AbstractColumn::ColumnMode Column::columnMode() const {
 	return d->columnMode();
 }
 
 /**
  * \brief Return the data vector size
  *
  * This returns the number of rows that actually contain data.
  * Rows beyond this can be masked etc. but should be ignored by filters,
  * plots etc.
  */
 int Column::rowCount() const {
 	return d->rowCount();
 }
 
 /**
  * \brief Return the column plot designation
  */
 AbstractColumn::PlotDesignation Column::plotDesignation() const {
 	return d->plotDesignation();
 }
 
 AbstractSimpleFilter* Column::outputFilter() const {
 	return d->outputFilter();
 }
 
 /**
  * \brief Return a wrapper column object used for String I/O.
  */
 ColumnStringIO* Column::asStringColumn() const {
 	return m_string_io;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //! \name IntervalAttribute related functions
 //@{
 ////////////////////////////////////////////////////////////////////////////////
 /**
  * \brief Return the formula associated with row 'row'
  */
 QString Column::formula(int row) const {
 	return d->formula(row);
 }
 
 /**
  * \brief Return the intervals that have associated formulas
  *
  * This can be used to make a list of formulas with their intervals.
  * Here is some example code:
  *
  * \code
  * QStringList list;
  * QVector< Interval<int> > intervals = my_column.formulaIntervals();
  * foreach(Interval<int> interval, intervals)
  * 	list << QString(interval.toString() + ": " + my_column.formula(interval.start()));
  * \endcode
  */
 QVector< Interval<int> > Column::formulaIntervals() const {
 	return d->formulaIntervals();
 }
 
 void Column::handleFormatChange() {
 	DEBUG("Column::handleFormatChange() mode = " << ENUM_TO_STRING(AbstractColumn, ColumnMode, columnMode()));
 	if (columnMode() == AbstractColumn::DateTime) {
 		auto* input_filter = static_cast<String2DateTimeFilter*>(d->inputFilter());
 		auto* output_filter = static_cast<DateTime2StringFilter*>(d->outputFilter());
 		DEBUG("change format " << input_filter->format().toStdString() << " to " << output_filter->format().toStdString());
 		input_filter->setFormat(output_filter->format());
 	}
 
 	emit aspectDescriptionChanged(this); // the icon for the type changed
 	if (!m_suppressDataChangedSignal)
 		emit dataChanged(this); // all cells must be repainted
 
 	d->statisticsAvailable = false;;
 	d->hasValuesAvailable = false;
 	DEBUG("Column::handleFormatChange() DONE");
 }
 
 /*!
  * calculates the minimal value in the column.
  * for \c count = 0, the minimum of all elements is returned.
  * for \c count > 0, the minimum of the first \count elements is returned.
  * for \c count < 0, the minimum of the last \count elements is returned.
  */
 double Column::minimum(int count) const {
 	double min = INFINITY;
 	if (count == 0 && d->statisticsAvailable)
 		min = const_cast<Column*>(this)->statistics().minimum;
 	else {
 		ColumnMode mode = columnMode();
 		int start, end;
 
 		if (count == 0) {
 			start = 0;
 			end = rowCount();
 		} else if (count > 0) {
 			start  = 0;
 			end = qMin(rowCount(), count);
 		} else {
 			start = qMax(rowCount() + count, 0);
 			end = rowCount();
 		}
 
 		switch (mode) {
 		case Numeric: {
 			QVector<double>* vec = static_cast<QVector<double>*>(data());
 			for (int row = start; row < end; ++row) {
 				const double val = vec->at(row);
 				if (std::isnan(val))
 					continue;
 
 				if (val < min)
 					min = val;
 			}
 			break;
 		}
 		case Integer: {
 			QVector<int>* vec = static_cast<QVector<int>*>(data());
 			for (int row = start; row < end; ++row) {
 				const int val = vec->at(row);
 
 				if (val < min)
 					min = val;
 			}
 			break;
 		}
 		case Text:
 			break;
 		case DateTime: {
 			QVector<QDateTime>* vec = static_cast<QVector<QDateTime>*>(data());
 			for (int row = start; row < end; ++row) {
 				const qint64 val = vec->at(row).toMSecsSinceEpoch();
 
 				if (val < min)
 					min = val;
 			}
 			break;
 		}
 		case Day:
 		case Month:
 		default:
 			break;
 		}
 
 	}
 
 	return min;
 }
 
 /*!
  * calculates the maximal value in the column.
  * for \c count = 0, the maximum of all elements is returned.
  * for \c count > 0, the maximum of the first \count elements is returned.
  * for \c count < 0, the maximum of the last \count elements is returned.
  */
 double Column::maximum(int count) const {
 	double max = -INFINITY;
 
 	if (count == 0 && d->statisticsAvailable)
 		max = const_cast<Column*>(this)->statistics().maximum;
 	else {
 		ColumnMode mode = columnMode();
 		int start, end;
 
 		if (count == 0) {
 			start = 0;
 			end = rowCount();
 		} else if (count > 0) {
 			start  = 0;
 			end = qMin(rowCount(), count);
 		} else {
 			start = qMax(rowCount() + count, 0);
 			end = rowCount();
 		}
 
 		switch (mode) {
 		case Numeric: {
 			QVector<double>* vec = static_cast<QVector<double>*>(data());
 			for (int row = start; row < end; ++row) {
 				const double val = vec->at(row);
 				if (std::isnan(val))
 					continue;
 
 				if (val > max)
 					max = val;
 			}
 			break;
 		}
 		case Integer: {
 			QVector<int>* vec = static_cast<QVector<int>*>(data());
 			for (int row = start; row < end; ++row) {
 				const int val = vec->at(row);
 
 				if (val > max)
 					max = val;
 			}
 			break;
 		}
 		case Text:
 			break;
 		case DateTime: {
 			QVector<QDateTime>* vec = static_cast<QVector<QDateTime>*>(data());
 			for (int row = start; row < end; ++row) {
 				const qint64 val = vec->at(row).toMSecsSinceEpoch();
 
 				if (val > max)
 					max = val;
 			}
 			break;
 		}
 		case Day:
 		case Month:
 		default:
 			break;
 		}
 
 	}
 
 	return max;
 }
diff --git a/src/backend/core/datatypes/String2DateTimeFilter.cpp b/src/backend/core/datatypes/String2DateTimeFilter.cpp
index 7eed6d125..49fe72785 100644
--- a/src/backend/core/datatypes/String2DateTimeFilter.cpp
+++ b/src/backend/core/datatypes/String2DateTimeFilter.cpp
@@ -1,161 +1,161 @@
 /***************************************************************************
     File                 : String2DateTimeFilter.cpp
     Project              : LabPlot
     --------------------------------------------------------------------
     Copyright            : (C) 2007 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2007 Knut Franke (knut.franke@gmx.de)
     Copyright            : (C) 2017 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description          : Conversion filter QString -> QDateTime.
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "String2DateTimeFilter.h"
 #include <QStringList>
 #include "backend/lib/XmlStreamReader.h"
 #include <QUndoCommand>
 #include <QDateTime>
 #include <QTime>
 #include <QDate>
 
 #include <KLocalizedString>
 
 class String2DateTimeFilterSetFormatCmd : public QUndoCommand {
 
 public:
 	String2DateTimeFilterSetFormatCmd(String2DateTimeFilter* target, const QString &new_format);
 
 	void redo() override;
 	void undo() override;
 
 private:
 	String2DateTimeFilter* m_target;
 	QString m_other_format;
 };
 
 AbstractColumn::ColumnMode String2DateTimeFilter::columnMode() const {
 	return AbstractColumn::DateTime;
 }
 
 QDateTime String2DateTimeFilter::dateTimeAt(int row) const {
 	if (!m_inputs.value(0)) return QDateTime();
 	QString input_value = m_inputs.value(0)->textAt(row);
 	if (input_value.isEmpty()) return QDateTime();
 
 	// first try the selected format string m_format
 	QDateTime result = QDateTime::fromString(input_value, m_format);
 	if(result.isValid())
 		return result;
 
 	// fallback:
 	// try other format strings built from date_formats and time_formats
 	// comma and space are valid separators between date and time
 	QStringList strings = input_value.simplified().split(',', QString::SkipEmptyParts);
 	if(strings.size() == 1) strings = strings.at(0).split(' ', QString::SkipEmptyParts);
 
 	if(strings.size() < 1)
 		return result; // invalid date/time from first attempt
 
 	QDate date_result;
 	QTime time_result;
 
 	QString date_string = strings.at(0).trimmed();
 	QString time_string;
 	if(strings.size() > 1)
 		time_string = strings.at(1).trimmed();
 	else
 		time_string = date_string;
 
 	// try to find a valid date
-	for (const auto& format: AbstractColumn::dateFormats()) {
+	for (const auto& format : AbstractColumn::dateFormats()) {
 		date_result = QDate::fromString(date_string, format);
 		if (date_result.isValid())
 			break;
 
 	}
 	// try to find a valid time
-	for (const auto& format: AbstractColumn::timeFormats()) {
+	for (const auto& format : AbstractColumn::timeFormats()) {
 		time_result = QTime::fromString(time_string, format);
 		if (time_result.isValid())
 			break;
 	}
 
 	if (!date_result.isValid() && time_result.isValid())
 		date_result.setDate(1900,1,1);	// this is what QDateTime does e.g. for QDateTime::fromString("00:00","hh:mm");
 	else if (date_result.isValid() && !time_result.isValid())
 		time_result = QTime(0, 0, 0, 0);
 
 	return QDateTime(date_result, time_result);
 }
 
 QDate String2DateTimeFilter::dateAt(int row) const {
 	return dateTimeAt(row).date();
 }
 
 QTime String2DateTimeFilter::timeAt(int row) const {
 	return dateTimeAt(row).time();
 }
 
 bool String2DateTimeFilter::inputAcceptable(int, const AbstractColumn* source) {
 	return source->columnMode() == AbstractColumn::Text;
 }
 
 void String2DateTimeFilter::writeExtraAttributes(QXmlStreamWriter* writer) const {
 	writer->writeAttribute("format", format());
 }
 
 bool String2DateTimeFilter::load(XmlStreamReader* reader, bool preview) {
 	if (preview)
 		return true;
 
 	QXmlStreamAttributes attribs = reader->attributes();
 	QString str = attribs.value(reader->namespaceUri().toString(), "format").toString();
 
 	if (AbstractSimpleFilter::load(reader, preview))
 		setFormat(str);
 	else
 		return false;
 
 	return !reader->hasError();
 }
 
 void String2DateTimeFilter::setFormat(const QString& format) {
 	exec(new String2DateTimeFilterSetFormatCmd(this, format));
 }
 
 String2DateTimeFilterSetFormatCmd::String2DateTimeFilterSetFormatCmd(String2DateTimeFilter* target, const QString &new_format)
 	: m_target(target), m_other_format(new_format) {
 	if(m_target->parentAspect())
 		setText(i18n("%1: set date-time format to %2", m_target->parentAspect()->name(), new_format));
 	else
 		setText(i18n("set date-time format to %1", new_format));
 }
 
 void String2DateTimeFilterSetFormatCmd::redo() {
 	QString tmp = m_target->m_format;
 	m_target->m_format = m_other_format;
 	m_other_format = tmp;
 	emit m_target->formatChanged();
 }
 
 void String2DateTimeFilterSetFormatCmd::undo() {
 	redo();
 }
 
diff --git a/src/backend/datapicker/Datapicker.cpp b/src/backend/datapicker/Datapicker.cpp
index 59c66ad44..7032757cc 100644
--- a/src/backend/datapicker/Datapicker.cpp
+++ b/src/backend/datapicker/Datapicker.cpp
@@ -1,392 +1,392 @@
 /***************************************************************************
     File                 : Datapicker.cpp
     Project              : LabPlot
     Description          : Datapicker
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Ankit Wagadre (wagadre.ankit@gmail.com)
     Copyright            : (C) 2015-2016 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 /***************************************************************************
  *                                                                         *
  *  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 "Datapicker.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/datapicker/DatapickerImage.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "commonfrontend/datapicker/DatapickerView.h"
 #include "backend/datapicker/DatapickerCurve.h"
 #include "backend/datapicker/Transform.h"
 #include "backend/datapicker/DatapickerPoint.h"
 
 #include <QGraphicsScene>
 #include "QIcon"
 #include <KLocalizedString>
 
 /**
  * \class Datapicker
  * \brief Top-level container for DatapickerCurve and DatapickerImage.
  * \ingroup backend
  */
 Datapicker::Datapicker(const QString& name, const bool loading) : AbstractPart(name),
 	m_view(nullptr),
 	m_activeCurve(nullptr),
 	m_transform(new Transform()),
 	m_image(nullptr) {
 
 	connect(this, &Datapicker::aspectAdded, this, &Datapicker::handleAspectAdded);
 	connect(this, &Datapicker::aspectAboutToBeRemoved, this, &Datapicker::handleAspectAboutToBeRemoved);
 
 	if (!loading)
 		init();
 }
 
 Datapicker::~Datapicker() {
 	delete m_transform;
 }
 
 void Datapicker::init() {
 	m_image = new DatapickerImage(i18n("Plot"));
 	m_image->setHidden(true);
 	setUndoAware(false);
 	addChild(m_image);
 	setUndoAware(true);
 
 	connect(m_image, &DatapickerImage::statusInfo, this, &Datapicker::statusInfo);
 }
 
 /*!
     Returns an icon to be used in the project explorer.
 */
 QIcon Datapicker::icon() const {
 	return QIcon::fromTheme("color-picker-black");
 }
 
 /*!
  * Returns a new context menu. The caller takes ownership of the menu.
  */
 QMenu* Datapicker::createContextMenu() {
 	QMenu* menu = AbstractPart::createContextMenu();
 	Q_ASSERT(menu);
 	m_image->createContextMenu(menu);
 	return menu;
 }
 
 QWidget* Datapicker::view() const {
 	if (!m_partView) {
 		m_view = new DatapickerView(const_cast<Datapicker*>(this));
 		m_partView = m_view;
 	}
 	return m_partView;
 }
 
 
 bool Datapicker::exportView() const {
 	Spreadsheet* s = currentSpreadsheet();
 	bool ret;
 	if (s)
 		ret = s->exportView();
 	else
 		ret = m_image->exportView();
 	return ret;
 }
 
 bool Datapicker::printView() {
 	Spreadsheet* s = currentSpreadsheet();
 	bool ret;
 	if (s)
 		ret = s->printView();
 	else
 		ret = m_image->printView();
 	return ret;
 }
 
 bool Datapicker::printPreview() const {
 	Spreadsheet* s = currentSpreadsheet();
 	bool ret;
 	if (s)
 		ret = s->printPreview();
 	else
 		ret = m_image->printPreview();
 	return ret;
 }
 
 DatapickerCurve* Datapicker::activeCurve() {
 	return m_activeCurve;
 }
 
 Spreadsheet* Datapicker::currentSpreadsheet() const {
 	if (!m_view)
 		return nullptr;
 
 	const int index = m_view->currentIndex();
 	if(index>0) {
 		DatapickerCurve* curve = child<DatapickerCurve>(index-1);
 		return curve->child<Spreadsheet>(0);
 	}
 	return nullptr;
 }
 
 DatapickerImage* Datapicker::image() const {
 	return m_image;
 }
 
 /*!
     this slot is called when a datapicker child is selected in the project explorer.
     emits \c datapickerItemSelected() to forward this event to the \c DatapickerView
     in order to select the corresponding tab.
  */
 void Datapicker::childSelected(const AbstractAspect* aspect) {
 	m_activeCurve = dynamic_cast<DatapickerCurve*>(const_cast<AbstractAspect*>(aspect));
 
 	int index = -1;
 	if (m_activeCurve) {
 		//if one of the curves is currently selected, select the image with the plot (the very first child)
 		index = 0;
 		emit statusInfo(i18n("%1, active curve \"%2\"", this->name(), m_activeCurve->name()));
 		emit requestUpdateActions();
 	} else {
 		const DatapickerCurve* curve = aspect->ancestor<const DatapickerCurve>();
 		index= indexOfChild<AbstractAspect>(curve);
 		++index; //+1 because of the hidden plot image being the first child and shown in the first tab in the view
 	}
 
 	emit datapickerItemSelected(index);
 }
 
 /*!
     this slot is called when a worksheet element is deselected in the project explorer.
  */
 void Datapicker::childDeselected(const AbstractAspect* aspect) {
 	Q_UNUSED(aspect);
 }
 
 /*!
  *  Emits the signal to select or to deselect the datapicker item (spreadsheet or image) with the index \c index
  *  in the project explorer, if \c selected=true or \c selected=false, respectively.
  *  The signal is handled in \c AspectTreeModel and forwarded to the tree view in \c ProjectExplorer.
  *  This function is called in \c DatapickerView when the current tab was changed
  */
 void Datapicker::setChildSelectedInView(int index, bool selected) {
 	//select/deselect the datapicker itself if the first tab "representing" the plot image and the curves was selected in the view
 	if (index==0) {
 		if (selected)
 			emit childAspectSelectedInView(this);
 		else {
 			emit childAspectDeselectedInView(this);
 
 			//deselect also all curves (they don't have any tab index in the view) that were potentially selected before
 			for (const auto* curve : children<const DatapickerCurve>())
 				emit childAspectDeselectedInView(curve);
 		}
 
 		return;
 	}
 
 	--index; //-1 because of the first tab in the view being reserved for the plot image and curves
 
 	//select/deselect the data spreadhseets
 	QVector<const Spreadsheet*> spreadsheets = children<const Spreadsheet>(AbstractAspect::Recursive);
 	const AbstractAspect* aspect = spreadsheets.at(index);
 	if (selected) {
 		emit childAspectSelectedInView(aspect);
 
 		//deselect the datapicker in the project explorer, if a child (spreadsheet or image) was selected.
 		//prevents unwanted multiple selection with datapicker if it was selected before.
 		emit childAspectDeselectedInView(this);
 	} else {
 		emit childAspectDeselectedInView(aspect);
 
 		//deselect also all children that were potentially selected before (columns of a spreadsheet)
 		for (const auto* child : aspect->children<const AbstractAspect>())
 			emit childAspectDeselectedInView(child);
 	}
 }
 
 /*!
 	Selects or deselects the datapicker or its current active curve in the project explorer.
     This function is called in \c DatapickerImageView.
 */
 void Datapicker::setSelectedInView(const bool b) {
 	if (b)
 		emit childAspectSelectedInView(this);
 	else
 		emit childAspectDeselectedInView(this);
 }
 
 void Datapicker::addNewPoint(const QPointF& pos, AbstractAspect* parentAspect) {
 	QVector<DatapickerPoint*> childPoints = parentAspect->children<DatapickerPoint>(AbstractAspect::IncludeHidden);
 	if (childPoints.isEmpty())
 		beginMacro(i18n("%1: add new point", parentAspect->name()));
 	else
 		beginMacro(i18n("%1: add new point %2", parentAspect->name(), childPoints.count()));
 
 	DatapickerPoint* newPoint = new DatapickerPoint(i18n("%1 Point", parentAspect->name()));
 	newPoint->setPosition(pos);
 	newPoint->setHidden(true);
 	parentAspect->addChild(newPoint);
 	newPoint->retransform();
 
 	DatapickerCurve* datapickerCurve = dynamic_cast<DatapickerCurve*>(parentAspect);
 	if (m_image == parentAspect) {
 		DatapickerImage::ReferencePoints points = m_image->axisPoints();
 		points.scenePos[childPoints.count()].setX(pos.x());
 		points.scenePos[childPoints.count()].setY(pos.y());
 		m_image->setAxisPoints(points);
 	} else if (datapickerCurve) {
 		newPoint->initErrorBar(datapickerCurve->curveErrorTypes());
 		datapickerCurve->updateData(newPoint);
 	}
 
 	endMacro();
 	emit requestUpdateActions();
 }
 
 QVector3D Datapicker::mapSceneToLogical(const QPointF& point) const {
 	return m_transform->mapSceneToLogical(point, m_image->axisPoints());
 }
 
 
 QVector3D Datapicker::mapSceneLengthToLogical(const QPointF& point) const {
 	return m_transform->mapSceneLengthToLogical(point, m_image->axisPoints());
 }
 
 void Datapicker::handleAspectAboutToBeRemoved(const AbstractAspect* aspect) {
 	const DatapickerCurve* curve = qobject_cast<const DatapickerCurve*>(aspect);
 	if (curve) {
 		//clear scene
 		QVector<DatapickerPoint*> childPoints = curve->children<DatapickerPoint>(IncludeHidden);
 		for (auto* point : childPoints)
 			handleChildAspectAboutToBeRemoved(point);
 
-		if (curve==m_activeCurve) {
+		if (curve == m_activeCurve) {
 			m_activeCurve = nullptr;
 			emit statusInfo("");
 		}
 	} else
 		handleChildAspectAboutToBeRemoved(aspect);
 
 	emit requestUpdateActions();
 }
 
 void Datapicker::handleAspectAdded(const AbstractAspect* aspect) {
 	const DatapickerPoint* addedPoint = qobject_cast<const DatapickerPoint*>(aspect);
 	const DatapickerCurve* curve = qobject_cast<const DatapickerCurve*>(aspect);
 	if (addedPoint)
 		handleChildAspectAdded(addedPoint);
 	else if (curve) {
 		QVector<DatapickerPoint*> childPoints = curve->children<DatapickerPoint>(IncludeHidden);
 		for (auto* point : childPoints)
 			handleChildAspectAdded(point);
 	} else
 		return;
 
 	qreal zVal = 0;
 	QVector<DatapickerPoint*> childPoints = m_image->children<DatapickerPoint>(IncludeHidden);
 	for (auto* point : childPoints)
 		point->graphicsItem()->setZValue(zVal++);
 
 	for (const auto* curve : children<DatapickerCurve>()) {
 		for (auto* point : curve->children<DatapickerPoint>(IncludeHidden))
 			point->graphicsItem()->setZValue(zVal++);
 	}
 
 	emit requestUpdateActions();
 }
 
 void Datapicker::handleChildAspectAboutToBeRemoved(const AbstractAspect* aspect) {
 	const DatapickerPoint *removedPoint = qobject_cast<const DatapickerPoint*>(aspect);
 	if (removedPoint) {
 		QGraphicsItem *item = removedPoint->graphicsItem();
 		Q_ASSERT(item != nullptr);
 		Q_ASSERT(m_image != nullptr);
 		m_image->scene()->removeItem(item);
 	}
 }
 
 void Datapicker::handleChildAspectAdded(const AbstractAspect* aspect) {
 	const DatapickerPoint* addedPoint = qobject_cast<const DatapickerPoint*>(aspect);
 	if (addedPoint) {
 		QGraphicsItem *item = addedPoint->graphicsItem();
 		Q_ASSERT(item != nullptr);
 		Q_ASSERT(m_image != nullptr);
 		m_image->scene()->addItem(item);
 	}
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 
 //! Save as XML
 void Datapicker::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement( "datapicker" );
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//serialize all children
 	for (auto* child : children<AbstractAspect>(IncludeHidden))
 		child->save(writer);
 
 	writer->writeEndElement(); // close "datapicker" section
 }
 
 //! Load from XML
 bool Datapicker::load(XmlStreamReader* reader, bool preview) {
 	if (!readBasicAttributes(reader))
 		return false;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "datapicker")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "datapickerImage") {
 			DatapickerImage* plot = new DatapickerImage(i18n("Plot"), true);
 			if (!plot->load(reader, preview)) {
 				delete plot;
 				return false;
 			} else {
 				plot->setHidden(true);
 				addChild(plot);
 				m_image = plot;
 			}
 		} else if (reader->name() == "datapickerCurve") {
 			DatapickerCurve* curve = new DatapickerCurve("");
 			if (!curve->load(reader, preview)) {
 				delete curve;
 				return false;
 			} else
 				addChild(curve);
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown datapicker element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	for (auto* aspect : children<AbstractAspect>(IncludeHidden)) {
 		for (auto* point : aspect->children<DatapickerPoint>(IncludeHidden))
 			handleAspectAdded(point);
 	}
 
 	return true;
 }
diff --git a/src/backend/datapicker/DatapickerPoint.cpp b/src/backend/datapicker/DatapickerPoint.cpp
index d99637ace..b2413f5fe 100644
--- a/src/backend/datapicker/DatapickerPoint.cpp
+++ b/src/backend/datapicker/DatapickerPoint.cpp
@@ -1,549 +1,549 @@
 /***************************************************************************
     File                 : DatapickerPoint.cpp
     Project              : LabPlot
     Description          : Graphic Item for coordinate points of Datapicker
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Ankit Wagadre (wagadre.ankit@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 "DatapickerPoint.h"
 #include "backend/worksheet/Worksheet.h"
 #include "DatapickerPointPrivate.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/datapicker/DatapickerCurve.h"
 
 #include <QPainter>
 #include <QGraphicsScene>
 #include <QMenu>
 #include <QGraphicsSceneMouseEvent>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 QPen DatapickerPoint::selectedPen = QPen(Qt::darkBlue, 3, Qt::SolidLine);
 float DatapickerPoint::selectedOpacity = 0.3f;
 
 /**
  * \class ErrorBarItem
  * \brief A customizable error-bar for DatapickerPoint.
  */
 
 ErrorBarItem::ErrorBarItem(DatapickerPoint *parent, const ErrorBarType& type) :
 	QGraphicsRectItem(parent->graphicsItem()),
 	barLineItem(new QGraphicsLineItem(parent->graphicsItem())),
 	m_type(type),
 	m_parentItem(parent) {
 	setFlag(QGraphicsItem::ItemIsMovable);
 	setFlag(QGraphicsItem::ItemIsSelectable);
 	setFlag(QGraphicsItem::ItemSendsGeometryChanges);
 	initRect();
 }
 
 void ErrorBarItem::initRect() {
 	QRectF xBarRect(-0.15, -0.5, 0.3, 1);
 	QRectF yBarRect(-0.5, -0.15, 1, 0.3);
 
 	if (m_type == PlusDeltaX || m_type == MinusDeltaX)
 		m_rect = xBarRect;
 	else
 		m_rect = yBarRect;
 }
 
 void ErrorBarItem::setPosition(const QPointF& position) {
 	setPos(position);
 	barLineItem->setLine(0, 0, position.x(), position.y());
 }
 
 void ErrorBarItem::setRectSize(const qreal size) {
 	QMatrix matrix;
 	matrix.scale(size, size);
 	setRect(matrix.mapRect(m_rect));
 }
 
 void ErrorBarItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
 	if (m_type == PlusDeltaX)
 		m_parentItem->setPlusDeltaXPos(pos());
 	else if (m_type == MinusDeltaX)
 		m_parentItem->setMinusDeltaXPos(pos());
 	else if (m_type == PlusDeltaY)
 		m_parentItem->setPlusDeltaYPos(pos());
 	else if (m_type == MinusDeltaY)
 		m_parentItem->setMinusDeltaYPos(pos());
 
 	QGraphicsItem::mouseReleaseEvent(event);
 }
 
 QVariant ErrorBarItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) {
 	if (change == QGraphicsItem::ItemPositionChange) {
 		QPointF newPos = value.toPointF();
 		barLineItem->setLine(0, 0, newPos.x(), newPos.y());
 	}
 
 	return QGraphicsRectItem::itemChange(change, value);
 }
 
 /**
  * \class Datapicker-Point
  * \brief A customizable symbol supports error-bars.
  *
  * The datapicker-Point is aligned relative to the specified position.
  * The position can be either specified by mouse events or by providing the
  * x- and y- coordinates in parent's coordinate system, or by specifying one
  * of the predefined position flags (\ca HorizontalPosition, \ca VerticalPosition).
  */
 
 DatapickerPoint::DatapickerPoint(const QString& name):AbstractAspect(name),
 	d_ptr(new DatapickerPointPrivate(this)) {
 
 	init();
 }
 
 DatapickerPoint::DatapickerPoint(const QString& name, DatapickerPointPrivate *dd):AbstractAspect(name), d_ptr(dd) {
 	init();
 }
 
 //no need to delete the d-pointer here - it inherits from QGraphicsItem
 //and is deleted during the cleanup in QGraphicsScene
 DatapickerPoint::~DatapickerPoint() = default;
 
 void DatapickerPoint::init() {
 	Q_D(DatapickerPoint);
 
 	KConfig config;
 	KConfigGroup group;
 	group = config.group("DatapickerPoint");
 	d->position.setX( group.readEntry("PositionXValue", Worksheet::convertToSceneUnits(1, Worksheet::Centimeter)) );
 	d->position.setY( group.readEntry("PositionYValue", Worksheet::convertToSceneUnits(1, Worksheet::Centimeter)) );
 	d->plusDeltaXPos = group.readEntry("PlusDeltaXPos", QPointF(30, 0));
 	d->minusDeltaXPos = group.readEntry("MinusDeltaXPos", QPointF(-30, 0));
 	d->plusDeltaYPos = group.readEntry("PlusDeltaYPos", QPointF(0, -30));
 	d->minusDeltaYPos = group.readEntry("MinusDeltaYPos", QPointF(0, 30));
 }
 
 void DatapickerPoint::initErrorBar(const DatapickerCurve::Errors& errors) {
 	m_errorBarItemList.clear();
 	if (errors.x != DatapickerCurve::NoError) {
 		ErrorBarItem* plusDeltaXItem = new ErrorBarItem(this, ErrorBarItem::PlusDeltaX);
 		plusDeltaXItem->setPosition(plusDeltaXPos());
 		connect(this, &DatapickerPoint::plusDeltaXPosChanged, plusDeltaXItem, &ErrorBarItem::setPosition);
 
 		ErrorBarItem* minusDeltaXItem = new ErrorBarItem(this, ErrorBarItem::MinusDeltaX);
 		minusDeltaXItem->setPosition(minusDeltaXPos());
 		connect(this, &DatapickerPoint::minusDeltaXPosChanged, minusDeltaXItem, &ErrorBarItem::setPosition);
 
 		m_errorBarItemList<<plusDeltaXItem<<minusDeltaXItem;
 	}
 
 	if (errors.y != DatapickerCurve::NoError) {
 		ErrorBarItem* plusDeltaYItem = new ErrorBarItem(this, ErrorBarItem::PlusDeltaY);
 		plusDeltaYItem->setPosition(plusDeltaYPos());
 		connect(this, &DatapickerPoint::plusDeltaYPosChanged, plusDeltaYItem, &ErrorBarItem::setPosition);
 
 		ErrorBarItem* minusDeltaYItem = new ErrorBarItem(this, ErrorBarItem::MinusDeltaY);
 		minusDeltaYItem->setPosition(minusDeltaYPos());
 		connect(this, &DatapickerPoint::minusDeltaYPosChanged, minusDeltaYItem, &ErrorBarItem::setPosition);
 
 		m_errorBarItemList<<plusDeltaYItem<<minusDeltaYItem;
 	}
 
 	retransform();
 }
 
 /*!
     Returns an icon to be used in the project explorer.
 */
 QIcon DatapickerPoint::icon() const {
 	return QIcon::fromTheme("draw-cross");
 }
 
 QMenu* DatapickerPoint::createContextMenu() {
 	QMenu* menu = AbstractAspect::createContextMenu();
 	return menu;
 }
 
 QGraphicsItem* DatapickerPoint::graphicsItem() const {
 	return d_ptr;
 }
 
 void DatapickerPoint::setParentGraphicsItem(QGraphicsItem* item) {
 	Q_D(DatapickerPoint);
 	d->setParentItem(item);
 }
 
 void DatapickerPoint::retransform() {
 	Q_D(DatapickerPoint);
 	d->retransform();
 }
 
 /* ============================ getter methods ================= */
 //point
 CLASS_SHARED_D_READER_IMPL(DatapickerPoint, QPointF, position, position)
 //error-bar
 CLASS_SHARED_D_READER_IMPL(DatapickerPoint, QPointF, plusDeltaXPos, plusDeltaXPos)
 CLASS_SHARED_D_READER_IMPL(DatapickerPoint, QPointF, minusDeltaXPos, minusDeltaXPos)
 CLASS_SHARED_D_READER_IMPL(DatapickerPoint, QPointF, plusDeltaYPos, plusDeltaYPos)
 CLASS_SHARED_D_READER_IMPL(DatapickerPoint, QPointF, minusDeltaYPos, minusDeltaYPos)
 /* ============================ setter methods and undo commands ================= */
 STD_SETTER_CMD_IMPL_F_S(DatapickerPoint, SetPosition, QPointF, position, retransform)
 void DatapickerPoint::setPosition(const QPointF& pos) {
 	Q_D(DatapickerPoint);
 	if (pos!=d->position)
 		exec(new DatapickerPointSetPositionCmd(d, pos, ki18n("%1: set position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(DatapickerPoint, SetPlusDeltaXPos, QPointF, plusDeltaXPos, updateData)
 void DatapickerPoint::setPlusDeltaXPos(const QPointF& pos) {
 	Q_D(DatapickerPoint);
 	if ( pos != d->plusDeltaXPos ) {
 		DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(parentAspect());
 		if (!curve)
 			return;
 
 		beginMacro(i18n("%1: set +delta_X position", name()));
 		if (curve->curveErrorTypes().x == DatapickerCurve::SymmetricError) {
 			exec(new DatapickerPointSetPlusDeltaXPosCmd(d, pos, ki18n("%1: set +delta X position")));
 			setMinusDeltaXPos(QPointF(-qAbs(pos.x()), pos.y()));
 		} else
 			exec(new DatapickerPointSetPlusDeltaXPosCmd(d, pos, ki18n("%1: set +delta X position")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(DatapickerPoint, SetMinusDeltaXPos, QPointF, minusDeltaXPos, updateData)
 void DatapickerPoint::setMinusDeltaXPos(const QPointF& pos) {
 	Q_D(DatapickerPoint);
 	if ( pos != d->minusDeltaXPos ) {
 		DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(parentAspect());
 		if (!curve)
 			return;
 
 		beginMacro(i18n("%1: set -delta_X position", name()));
 		if (curve->curveErrorTypes().x == DatapickerCurve::SymmetricError) {
 			exec(new DatapickerPointSetMinusDeltaXPosCmd(d, pos, ki18n("%1: set -delta_X position")));
 			setPlusDeltaXPos(QPointF(qAbs(pos.x()), pos.y()));
 		} else
 			exec(new DatapickerPointSetMinusDeltaXPosCmd(d, pos, ki18n("%1: set -delta_X position")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(DatapickerPoint, SetPlusDeltaYPos, QPointF, plusDeltaYPos, updateData)
 void DatapickerPoint::setPlusDeltaYPos(const QPointF& pos) {
 	Q_D(DatapickerPoint);
 	if ( pos != d->plusDeltaYPos ) {
 		DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(parentAspect());
 		if (!curve)
 			return;
 
 		beginMacro(i18n("%1: set +delta_Y position", name()));
 		if (curve->curveErrorTypes().y == DatapickerCurve::SymmetricError) {
 			exec(new DatapickerPointSetPlusDeltaYPosCmd(d, pos, ki18n("%1: set +delta_Y position")));
 			setMinusDeltaYPos(QPointF(pos.x(), qAbs(pos.y())));
 		} else
 			exec(new DatapickerPointSetPlusDeltaYPosCmd(d, pos, ki18n("%1: set +delta_Y position")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(DatapickerPoint, SetMinusDeltaYPos, QPointF, minusDeltaYPos, updateData)
 void DatapickerPoint::setMinusDeltaYPos(const QPointF& pos) {
 	Q_D(DatapickerPoint);
 	if ( pos != d->minusDeltaYPos ) {
 		DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(parentAspect());
 		if (!curve)
 			return;
 
 		beginMacro(i18n("%1: set -delta_Y position", name()));
 		if (curve->curveErrorTypes().y == DatapickerCurve::SymmetricError) {
 			exec(new DatapickerPointSetMinusDeltaYPosCmd(d, pos, ki18n("%1: set -delta_Y position")));
 			setPlusDeltaYPos(QPointF(pos.x(), -qAbs(pos.y())));
 		} else
 			exec(new DatapickerPointSetMinusDeltaYPosCmd(d, pos, ki18n("%1: set -delta_Y position")));
 		endMacro();
 	}
 }
 
 void DatapickerPoint::setPrinting(bool on) {
 	Q_D(DatapickerPoint);
 	d->m_printing = on;
 }
 
 //##############################################################################
 //####################### Private implementation ###############################
 //##############################################################################
 DatapickerPointPrivate::DatapickerPointPrivate(DatapickerPoint* owner)
 	: m_printing(false), q(owner) {
 
 	setFlag(QGraphicsItem::ItemSendsGeometryChanges);
 	setFlag(QGraphicsItem::ItemIsSelectable);
 	setAcceptHoverEvents(true);
 }
 
 QString DatapickerPointPrivate::name() const {
 	return q->name();
 }
 
 /*!
     calculates the position and the bounding box of the item/point. Called on geometry or properties changes.
  */
 void DatapickerPointPrivate::retransform() {
 	updatePropeties();
 	setPos(position);
 	QPainterPath path = Symbol::pathFromStyle(pointStyle);
 	boundingRectangle = path.boundingRect();
 	recalcShapeAndBoundingRect();
 	retransformErrorBar();
 	updateData();
 }
 
 /*!
   update color and size of all error-bar.
 */
 void DatapickerPointPrivate::retransformErrorBar() {
-	for(auto* item : q->m_errorBarItemList) {
+	for (auto* item : q->m_errorBarItemList) {
 		if (item) {
 			item->setBrush(errorBarBrush);
 			item->setPen(errorBarPen);
 			item->setRectSize(errorBarSize);
 		}
 	}
 }
 
 /*!
   update datasheet on any change in position of Datapicker-Point or it's error-bar.
 */
 void DatapickerPointPrivate::updateData() {
 	DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(q->parentAspect());
 	if (curve)
 		curve->updateData(q);
 }
 
 void DatapickerPointPrivate::updatePropeties() {
 	DatapickerCurve* curve = dynamic_cast<DatapickerCurve*>(q->parentAspect());
 	DatapickerImage* image = dynamic_cast<DatapickerImage*>(q->parentAspect());
 	if (image) {
 		rotationAngle = image->pointRotationAngle();
 		pointStyle = image->pointStyle();
 		brush = image->pointBrush();
 		pen = image->pointPen();
 		opacity = image->pointOpacity();
 		size = image->pointSize();
 		setVisible(image->pointVisibility());
 	} else if (curve) {
 		rotationAngle = curve->pointRotationAngle();
 		pointStyle = curve->pointStyle();
 		brush = curve->pointBrush();
 		pen = curve->pointPen();
 		opacity = curve->pointOpacity();
 		size = curve->pointSize();
 		errorBarBrush = curve->pointErrorBarBrush();
 		errorBarPen = curve->pointErrorBarPen();
 		errorBarSize = curve->pointErrorBarSize();
 		setVisible(curve->pointVisibility());
 	}
 }
 
 /*!
     Returns the outer bounds of the item as a rectangle.
  */
 QRectF DatapickerPointPrivate::boundingRect() const {
 	return transformedBoundingRectangle;
 }
 
 /*!
     Returns the shape of this item as a QPainterPath in local coordinates.
 */
 QPainterPath DatapickerPointPrivate::shape() const {
 	return itemShape;
 }
 
 /*!
   recalculates the outer bounds and the shape of the item.
 */
 void DatapickerPointPrivate::recalcShapeAndBoundingRect() {
 	prepareGeometryChange();
 
 	QMatrix matrix;
 	matrix.scale(size, size);
 	matrix.rotate(-rotationAngle);
 	transformedBoundingRectangle = matrix.mapRect(boundingRectangle);
 	itemShape = QPainterPath();
 	itemShape.addRect(transformedBoundingRectangle);
 }
 
 void DatapickerPointPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget * widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	QPainterPath path = Symbol::pathFromStyle(pointStyle);
 	QTransform trafo;
 	trafo.scale(size, size);
 	path = trafo.map(path);
 	trafo.reset();
 	if (rotationAngle != 0) {
 		trafo.rotate(-rotationAngle);
 		path = trafo.map(path);
 	}
 	painter->save();
 	painter->setPen(pen);
 	painter->setBrush(brush);
 	painter->setOpacity(opacity);
 	painter->drawPath(path);
 	painter->restore();
 
 	if (isSelected() && !m_printing) {
 		painter->setPen(q->selectedPen);
 		painter->setOpacity(q->selectedOpacity);
 		painter->drawPath(itemShape);
 	}
 }
 
 void DatapickerPointPrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	q->createContextMenu()->exec(event->screenPos());
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void DatapickerPoint::save(QXmlStreamWriter* writer) const {
 	Q_D(const DatapickerPoint);
 
 	writer->writeStartElement( "datapickerPoint" );
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//geometry
 	writer->writeStartElement( "geometry" );
 	writer->writeAttribute( "x", QString::number(d->position.x()) );
 	writer->writeAttribute( "y", QString::number(d->position.y()) );
 	writer->writeEndElement();
 
 	writer->writeStartElement( "errorBar" );
 	writer->writeAttribute( "plusDeltaXPos_x", QString::number(d->plusDeltaXPos.x()) );
 	writer->writeAttribute( "plusDeltaXPos_y", QString::number(d->plusDeltaXPos.y()) );
 	writer->writeAttribute( "minusDeltaXPos_x", QString::number(d->minusDeltaXPos.x()) );
 	writer->writeAttribute( "minusDeltaXPos_y", QString::number(d->minusDeltaXPos.y()) );
 	writer->writeAttribute( "plusDeltaYPos_x", QString::number(d->plusDeltaYPos.x()) );
 	writer->writeAttribute( "plusDeltaYPos_y", QString::number(d->plusDeltaYPos.y()) );
 	writer->writeAttribute( "minusDeltaYPos_x", QString::number(d->minusDeltaYPos.x()) );
 	writer->writeAttribute( "minusDeltaYPos_y", QString::number(d->minusDeltaYPos.y()) );
 	writer->writeEndElement();
 
 	writer->writeEndElement(); // close "DatapickerPoint" section
 }
 
 //! Load from XML
 bool DatapickerPoint::load(XmlStreamReader* reader, bool preview) {
 	Q_D(DatapickerPoint);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "datapickerPoint")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (!preview && reader->name() == "geometry") {
 			attribs = reader->attributes();
 
 			str = attribs.value("x").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("x").toString());
 			else
 				d->position.setX(str.toDouble());
 
 			str = attribs.value("y").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("y").toString());
 			else
 				d->position.setY(str.toDouble());
 		} else if (!preview && reader->name() == "errorBar") {
 			attribs = reader->attributes();
 
 			str = attribs.value("plusDeltaXPos_x").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("plusDeltaXPos_x").toString());
 			else
 				d->plusDeltaXPos.setX(str.toDouble());
 
 			str = attribs.value("plusDeltaXPos_y").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("plusDeltaXPos_y").toString());
 			else
 				d->plusDeltaXPos.setY(str.toDouble());
 
 			str = attribs.value("minusDeltaXPos_x").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("minusDeltaXPos_x").toString());
 			else
 				d->minusDeltaXPos.setX(str.toDouble());
 
 			str = attribs.value("minusDeltaXPos_y").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("minusDeltaXPos_y").toString());
 			else
 				d->minusDeltaXPos.setY(str.toDouble());
 
 			str = attribs.value("plusDeltaYPos_x").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("plusDeltaYPos_x").toString());
 			else
 				d->plusDeltaYPos.setX(str.toDouble());
 
 			str = attribs.value("plusDeltaYPos_y").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("plusDeltaYPos_y").toString());
 			else
 				d->plusDeltaYPos.setY(str.toDouble());
 
 			str = attribs.value("minusDeltaYPos_x").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("minusDeltaYPos_x").toString());
 			else
 				d->minusDeltaYPos.setX(str.toDouble());
 
 			str = attribs.value("minusDeltaYPos_y").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("minusDeltaYPos_y").toString());
 			else
 				d->minusDeltaYPos.setY(str.toDouble());
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	retransform();
 	return true;
 }
diff --git a/src/backend/datapicker/Segments.cpp b/src/backend/datapicker/Segments.cpp
index e53ed32ca..17de2276f 100644
--- a/src/backend/datapicker/Segments.cpp
+++ b/src/backend/datapicker/Segments.cpp
@@ -1,293 +1,293 @@
 /***************************************************************************
     File                 : Segments.cpp
     Project              : LabPlot
     Description          : Contains methods to trace curve of image/plot
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Ankit Wagadre (wagadre.ankit@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 "Segments.h"
 #include "backend/datapicker/Segment.h"
 #include "backend/datapicker/ImageEditor.h"
 
 #include <QGraphicsScene>
 #include <QImage>
 #include <QGraphicsItem>
 
 /**
  * \class Segments
  * \brief container to open image/plot.
  *
  * this class is a container for all of the segment. a segment is a set
  * of linked lines that run along a curve in the original image. the
  * main complication is that curves in the original image cross each other
  * and other things like grid lines. we rely on the user to link
  * multiple segments together to get points along the entire curve length
  * * \ingroup datapicker
  */
 
 Segments::Segments(DatapickerImage* image): m_image(image) {
 }
 
 /*!
     segments are built when the original image is loaded. they start out hidden
      and remain so until showSegments is called
 */
 void Segments::makeSegments(QImage &imageProcessed) {
 // 	QElapsedTimer timer;
 // 	timer.start();
 	clearSegments();
 
 	const int width = imageProcessed.width();
 	const int height = imageProcessed.height();
 
 	// for each new column of pixels, loop through the runs. a run is defined as
 	// one or more colored pixels that are all touching, with one uncolored pixel or the
 	// image boundary at each end of the set. for each set in the current column, count
 	// the number of runs it touches in the adjacent (left and right) columns. here is
 	// the pseudocode:
 	//   if ((L > 1) || (R > 1))
 	//     "this run is at a branch point so ignore the set"
 	//   else
 	//     if (L == 0)
 	//       "this run is the start of a new segment"
 	//     else
 	//       "this run is appended to the segment on the left
 
 	bool* lastBool = new bool [height];
 	bool* currBool = new bool [height];
 	bool* nextBool = new bool [height];
 	Segment** lastSegment = new Segment* [(size_t)height];
 	Segment** currSegment = new Segment* [(size_t)height];
 	loadSegment(lastSegment, height);
 
 	//initialize one column of boolean flags using the pixels of the specified column
 	for (int y = 0; y < height; ++y) {
 		lastBool[y] = false;
 		currBool[y] = ImageEditor::processedPixelIsOn(imageProcessed, 0, y);
 		nextBool[y] = ImageEditor::processedPixelIsOn(imageProcessed, 1, y);
 	}
 
 	for (int x = 0; x < width; ++x) {
 		matchRunsToSegments(x, height, lastBool, lastSegment, currBool, currSegment, nextBool);
 
 		// get ready for next column
 		for (int y = 0; y < height; ++y) {
 			lastBool[y] = currBool[y];
 			currBool[y] = nextBool[y];
 		}
 
 		if (x + 1 < width) {
 			for (int y = 0; y < height; ++y)
 				nextBool[y] = ImageEditor::processedPixelIsOn(imageProcessed, x+1, y);
 		}
 		scrollSegment(lastSegment, currSegment, height);
 	}
 
 	delete[] lastBool;
 	delete[] currBool;
 	delete[] nextBool;
 	delete[] lastSegment;
 	delete[] currSegment;
 // 	qDebug() << "Made segments in " << timer.elapsed() << "ms";
 }
 
 /*!
     scroll the segment pointers of the right column into the left column
 */
 void Segments::scrollSegment(Segment** left, Segment** right, int height) {
 	for (int y = 0; y < height; ++y)
 		left [y] = right [y];
 }
 
 /*!
     identify the runs in a column, and connect them to segments
 */
 void Segments::matchRunsToSegments(int x, int height, bool* lastBool, Segment** lastSegment,
                                    bool* currBool, Segment** currSegment, bool* nextBool) {
 	loadSegment(currSegment, height);
 
 	int yStart = 0;
 	bool inRun = false;
 	for (int y = 0; y < height; ++y) {
 		if (!inRun && currBool [y]) {
 			inRun = true;
 			yStart = y;
 		}
 
 		if ((y + 1 >= height) || !currBool [y + 1]) {
 			if (inRun)
 				finishRun(lastBool, nextBool, lastSegment, currSegment, x, yStart, y, height);
 
 			inRun = false;
 		}
 	}
 
 	removeUnneededLines(lastSegment, currSegment, height);
 }
 
 /*!
     remove unneeded lines belonging to segments that just finished in the previous column.
 */
 void Segments::removeUnneededLines(Segment** lastSegment, Segment** currSegment, int height) {
 	Segment* segLast = nullptr;
 	for (int yLast = 0; yLast < height; ++yLast) {
 		if (lastSegment [yLast] && (lastSegment [yLast] != segLast)) {
 			segLast = lastSegment [yLast];
 
 			bool found = false;
 			for (int yCur = 0; yCur < height; ++yCur)
 				if (segLast == currSegment [yCur]) {
 					found = true;
 					break;
 				}
 
 			if (!found) {
 				if (segLast->length < m_image->minSegmentLength()) {
 					// remove whole segment since it is too short
 					m_image->scene()->removeItem(segLast->graphicsItem());
 					segments.removeOne(segLast);
 				}
 			}
 		}
 	}
 }
 
 /*!
     initialize one column of segment pointers
 */
 void Segments::loadSegment(Segment** columnSegment, int height) {
 	for (int y = 0; y < height; ++y)
 		columnSegment [y] = nullptr;
 }
 
 void Segments::clearSegments() {
-	for(auto* seg : segments)
+	for (auto* seg : segments)
 		m_image->scene()->removeItem(seg->graphicsItem());
 
 	segments.clear();
 }
 
 /*!
     set segments visible
 */
 void Segments::setSegmentsVisible(bool on) {
-	for(auto* seg : segments)
+	for (auto* seg : segments)
 		seg->setVisible(on);
 }
 
 void Segments::setAcceptHoverEvents(bool on) {
 	for (auto* seg : segments) {
 		QGraphicsItem *item = seg->graphicsItem();
 		item->setAcceptHoverEvents(on);
 		item->setFlag(QGraphicsItem::ItemIsSelectable, on);
 	}
 }
 
 /*!
     process a run of pixels. if there are fewer than two adjacent pixel runs on
     either side, this run will be added to an existing segment, or the start of
     a new segment
 */
 void Segments::finishRun(bool* lastBool, bool* nextBool, Segment** lastSegment, Segment** currSegment,
                          int x, int yStart, int yStop, int height) {
 
 	// count runs that touch on the left
 	if (adjacentRuns(lastBool, yStart, yStop, height) > 1)
 		return;
 
 	// count runs that touch on the right
 	if (adjacentRuns(nextBool, yStart, yStop, height) > 1)
 		return;
 
 	Segment* seg;
 	int y = (int) ((yStart + yStop) / 2);
 	if (adjacentSegments(lastSegment, yStart, yStop, height) == 0) {
 		seg = new Segment(m_image);
 		QLine* line = new QLine(QPoint(x, y),QPoint( x, y));
 		seg->path.append(line);
 		seg->yLast  = y;
 		segments.append(seg);
 	} else {
 		// this is the continuation of an existing segment
 		seg = adjacentSegment(lastSegment, yStart, yStop, height);
 		QLine* line = new QLine(QPoint(x - 1, seg->yLast),QPoint( x, y));
 		seg->length  += abs(1 + (seg->yLast - y)*(seg->yLast - y));
 		seg->path.append(line);
 		seg->yLast = y;
 	}
 
 	seg->retransform();
 
 	for (int y = yStart; y <= yStop; ++y)
 		currSegment [y] = seg;
 }
 
 /*!
     return the number of runs adjacent to the pixels from yStart to yStop (inclusive)
 */
 int Segments::adjacentRuns(bool* columnBool, int yStart, int yStop, int height) {
 	int runs = 0;
 	bool inRun = false;
 	for (int y = yStart - 1; y <= yStop + 1; ++y) {
 		if ((0 <= y) && (y < height)) {
 			if (!inRun && columnBool [y]) {
 				inRun = true;
 				++runs;
 			} else if (inRun && !columnBool [y])
 				inRun = false;
 		}
 	}
 
 	return runs;
 }
 
 /*!
     find the single segment pointer among the adjacent pixels from yStart-1 to yStop+1
 */
 Segment* Segments::adjacentSegment(Segment** lastSegment, int yStart, int yStop, int height) {
 	for (int y = yStart - 1; y <= yStop + 1; ++y) {
 		if ((0 <= y) && (y < height))
 			if (lastSegment [y])
 				return lastSegment [y];
 	}
 
 	return nullptr;
 }
 
 /*!
     return the number of segments adjacent to the pixels from yStart to yStop (inclusive)
 */
 int Segments::adjacentSegments(Segment** lastSegment, int yStart, int yStop, int height) {
 	int count = 0;
 	bool inSegment = false;
 	for (int y = yStart - 1; y <= yStop + 1; ++y) {
 		if ((0 <= y) && (y < height)) {
 			if (!inSegment && lastSegment [y]) {
 				inSegment = true;
 				++count;
 			} else if (inSegment && !lastSegment [y])
 				inSegment = false;
 		}
 	}
 
 	return count;
 }
diff --git a/src/backend/datasources/filters/AsciiFilter.cpp b/src/backend/datasources/filters/AsciiFilter.cpp
index 4a36d587b..6e9f26131 100644
--- a/src/backend/datasources/filters/AsciiFilter.cpp
+++ b/src/backend/datasources/filters/AsciiFilter.cpp
@@ -1,2945 +1,2945 @@
 /***************************************************************************
 File                 : AsciiFilter.cpp
 Project              : LabPlot
 Description          : ASCII I/O-filter
 --------------------------------------------------------------------
 Copyright            : (C) 2009-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
 Copyright            : (C) 2009-2017 Alexander Semke (alexander.semke@web.de)
 
 ***************************************************************************/
 
 /***************************************************************************
 *                                                                         *
 *  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/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/datasources/filters/AsciiFilter.h"
 #include "backend/datasources/filters/AsciiFilterPrivate.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/lib/macros.h"
 #include "backend/lib/trace.h"
 
 #ifdef HAVE_MQTT
 #include "backend/datasources/MQTTClient.h"
 #include "backend/datasources/MQTTTopic.h"
 #endif
 
 #include <QTextStream>
 #include <KLocalizedString>
 #include <KFilterDev>
 #include <QProcess>
 #include <QDateTime>
 
 /*!
 \class AsciiFilter
 \brief Manages the import/export of data organized as columns (vectors) from/to an ASCII-file.
 
 \ingroup datasources
 */
 AsciiFilter::AsciiFilter() : AbstractFileFilter(), d(new AsciiFilterPrivate(this)) {}
 
 AsciiFilter::~AsciiFilter() = default;
 
 /*!
   reads the content of the device \c device.
 */
 void AsciiFilter::readDataFromDevice(QIODevice& device, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	d->readDataFromDevice(device, dataSource, importMode, lines);
 }
 
 void AsciiFilter::readFromLiveDeviceNotFile(QIODevice &device, AbstractDataSource* dataSource) {
 	d->readFromLiveDevice(device, dataSource);
 }
 
 qint64 AsciiFilter::readFromLiveDevice(QIODevice& device, AbstractDataSource* dataSource, qint64 from) {
 	return d->readFromLiveDevice(device, dataSource, from);
 }
 
 #ifdef HAVE_MQTT
 /*!
   reads the content of a message received by the topic.
 */
 void AsciiFilter::readMQTTTopic(const QString& message, const QString& topic, AbstractDataSource*dataSource) {
 	d->readMQTTTopic(message, topic, dataSource);
 }
 
 /*!
   provides a preview of the data received by the topic.
 */
 void AsciiFilter::MQTTPreview(QVector<QStringList>& list, const QString& message, const QString& topic) {
 	d->MQTTPreview(list, message, topic);
 }
 
 /*!
   Returns the statistical data, that the MQTTTopic needs for the will message.
 */
 QString AsciiFilter::MQTTColumnStatistics(const MQTTTopic* topic) const{
 	return d->MQTTColumnStatistics(topic);
 }
 
 /*!
   Returns the column mode of the last column (the value column of the MQTTTopic).
 */
 AbstractColumn::ColumnMode AsciiFilter::MQTTColumnMode() const{
 	return d->MQTTColumnMode();
 }
 
 /*!
   After the MQTTTopic is loaded, prepares the filter for reading.
 */
 void AsciiFilter::setPreparedForMQTT(bool prepared, MQTTTopic* topic, const QString& separator) {
 	d->setPreparedForMQTT(prepared, topic, separator);
 }
 #endif
 
 /*!
   returns the separator used by the filter.
 */
 QString AsciiFilter::separator() const {
 	return d->separator();
 }
 
 /*!
   returns the separator used by the filter.
 */
 int AsciiFilter::isPrepared() {
 	return d->isPrepared();
 }
 
 /*!
   reads the content of the file \c fileName.
 */
 void AsciiFilter::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode) {
 	d->readDataFromFile(fileName, dataSource, importMode);
 }
 
 QVector<QStringList> AsciiFilter::preview(const QString& fileName, int lines) {
 	return d->preview(fileName, lines);
 }
 
 QVector<QStringList> AsciiFilter::preview(QIODevice &device) {
 	return d->preview(device);
 }
 
 /*!
   reads the content of the file \c fileName to the data source \c dataSource.
 */
 //void AsciiFilter::read(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode) {
 //	d->read(fileName, dataSource, importMode);
 //}
 
 
 /*!
 writes the content of the data source \c dataSource to the file \c fileName.
 */
 void AsciiFilter::write(const QString& fileName, AbstractDataSource* dataSource) {
 	d->write(fileName, dataSource);
 // 	emit()
 }
 
 /*!
   loads the predefined filter settings for \c filterName
 */
 void AsciiFilter::loadFilterSettings(const QString& filterName) {
 	Q_UNUSED(filterName);
 }
 
 /*!
   saves the current settings as a new filter with the name \c filterName
 */
 void AsciiFilter::saveFilterSettings(const QString& filterName) const {
 	Q_UNUSED(filterName);
 }
 
 /*!
   returns the list with the names of all saved
   (system wide or user defined) filter settings.
 */
 QStringList AsciiFilter::predefinedFilters() {
 	return QStringList();
 }
 
 /*!
   returns the list of all predefined separator characters.
 */
 QStringList AsciiFilter::separatorCharacters() {
 	return (QStringList() << "auto" << "TAB" << "SPACE" << "," << ";" << ":"
 	        << ",TAB" << ";TAB" << ":TAB" << ",SPACE" << ";SPACE" << ":SPACE" << "2xSPACE" << "3xSPACE" << "4xSPACE" << "2xTAB");
 }
 
 /*!
 returns the list of all predefined comment characters.
 */
 QStringList AsciiFilter::commentCharacters() {
 	return (QStringList() << "#" << "!" << "//" << "+" << "c" << ":" << ";");
 }
 
 /*!
 returns the list of all predefined data types.
 */
 QStringList AsciiFilter::dataTypes() {
 	const QMetaObject& mo = AbstractColumn::staticMetaObject;
 	const QMetaEnum& me = mo.enumerator(mo.indexOfEnumerator("ColumnMode"));
 	QStringList list;
 	for (int i = 0; i <= 100; ++i)	// me.keyCount() does not work because we have holes in enum
 		if (me.valueToKey(i))
 			list << me.valueToKey(i);
 	return list;
 }
 
 QString AsciiFilter::fileInfoString(const QString& fileName) {
 	QString info(i18n("Number of columns: %1", AsciiFilter::columnNumber(fileName)));
 	info += QLatin1String("<br>");
 	info += i18n("Number of lines: %1", AsciiFilter::lineNumber(fileName));
 	return info;
 }
 
 /*!
     returns the number of columns in the file \c fileName.
 */
 int AsciiFilter::columnNumber(const QString& fileName, const QString& separator) {
     KFilterDev device(fileName);
 	if (!device.open(QIODevice::ReadOnly)) {
 		DEBUG("Could not open file " << fileName.toStdString() << " for determining number of columns");
 		return -1;
 	}
 
 	QString line = device.readLine();
 	line.remove(QRegExp("[\\n\\r]"));
 
 	QStringList lineStringList;
 	if (separator.length() > 0)
 		lineStringList = line.split(separator);
 	else
 		lineStringList = line.split(QRegExp("\\s+"));
 	DEBUG("number of columns : " << lineStringList.size());
 
 	return lineStringList.size();
 }
 
 size_t AsciiFilter::lineNumber(const QString& fileName) {
 	KFilterDev device(fileName);
 
 	if (!device.open(QIODevice::ReadOnly)) {
 		DEBUG("Could not open file " << fileName.toStdString() << " to determine number of lines");
 
 		return 0;
 	}
 	if (!device.canReadLine())
 		return -1;
 
 	size_t lineCount = 0;
 	while (!device.atEnd()) {
 		device.readLine();
 		lineCount++;
 	}
 
 //TODO: wc is much faster but not portable
 	/*	QElapsedTimer myTimer;
 		myTimer.start();
 		QProcess wc;
 		wc.start(QString("wc"), QStringList() << "-l" << fileName);
 		size_t lineCount = 0;
 		while (wc.waitForReadyRead())
 			lineCount = wc.readLine().split(' ')[0].toInt();
 		lineCount++;	// last line not counted
 		DEBUG(" Elapsed time counting lines : " << myTimer.elapsed() << " ms");
 	*/
 	return lineCount;
 }
 
 /*!
   returns the number of lines in the device \c device and 0 if sequential.
   resets the position to 0!
 */
 size_t AsciiFilter::lineNumber(QIODevice &device) {
 	if (device.isSequential())
 		return 0;
 	if (!device.canReadLine())
 		DEBUG("WARNING in AsciiFilter::lineNumber(): device cannot 'readLine()' but using it anyway.");
 
 	size_t lineCount = 0;
 	device.seek(0);
 	while (!device.atEnd()) {
 		device.readLine();
 		lineCount++;
 	}
 	device.seek(0);
 
 	return lineCount;
 }
 
 void AsciiFilter::setCommentCharacter(const QString& s) {
 	d->commentCharacter = s;
 }
 QString AsciiFilter::commentCharacter() const {
 	return d->commentCharacter;
 }
 
 void AsciiFilter::setSeparatingCharacter(const QString& s) {
 	d->separatingCharacter = s;
 }
 QString AsciiFilter::separatingCharacter() const {
 	return d->separatingCharacter;
 }
 
 void AsciiFilter::setDateTimeFormat(const QString &f) {
 	d->dateTimeFormat = f;
 }
 QString AsciiFilter::dateTimeFormat() const {
 	return d->dateTimeFormat;
 }
 
 void AsciiFilter::setNumberFormat(QLocale::Language lang) {
 	d->numberFormat = lang;
 }
 QLocale::Language AsciiFilter::numberFormat() const {
 	return d->numberFormat;
 }
 
 void AsciiFilter::setAutoModeEnabled(const bool b) {
 	d->autoModeEnabled = b;
 }
 bool AsciiFilter::isAutoModeEnabled() const {
 	return d->autoModeEnabled;
 }
 
 void AsciiFilter::setHeaderEnabled(const bool b) {
 	d->headerEnabled = b;
 }
 bool AsciiFilter::isHeaderEnabled() const {
 	return d->headerEnabled;
 }
 
 void AsciiFilter::setSkipEmptyParts(const bool b) {
 	d->skipEmptyParts = b;
 }
 bool AsciiFilter::skipEmptyParts() const {
 	return d->skipEmptyParts;
 }
 
 void AsciiFilter::setCreateIndexEnabled(bool b) {
 	d->createIndexEnabled = b;
 }
 
 bool AsciiFilter::createIndexEnabled() const{
 	return d->createIndexEnabled;
 }
 
 void AsciiFilter::setSimplifyWhitespacesEnabled(bool b) {
 	d->simplifyWhitespacesEnabled = b;
 }
 bool AsciiFilter::simplifyWhitespacesEnabled() const {
 	return d->simplifyWhitespacesEnabled;
 }
 
 void AsciiFilter::setNaNValueToZero(bool b) {
 	if (b)
 		d->nanValue = 0;
 	else
 		d->nanValue = NAN;
 }
 bool AsciiFilter::NaNValueToZeroEnabled() const {
 	if (d->nanValue == 0)
 		return true;
 	return false;
 }
 
 void AsciiFilter::setRemoveQuotesEnabled(bool b) {
 	d->removeQuotesEnabled = b;
 }
 bool AsciiFilter::removeQuotesEnabled() const {
 	return d->removeQuotesEnabled;
 }
 
 void AsciiFilter::setVectorNames(const QString& s) {
 	d->vectorNames.clear();
 	if (!s.simplified().isEmpty())
 		d->vectorNames = s.simplified().split(' ');
 }
 QStringList AsciiFilter::vectorNames() const {
 	return d->vectorNames;
 }
 
 QVector<AbstractColumn::ColumnMode> AsciiFilter::columnModes() {
 	return d->columnModes;
 }
 
 void AsciiFilter::setStartRow(const int r) {
 	d->startRow = r;
 }
 int AsciiFilter::startRow() const {
 	return d->startRow;
 }
 
 void AsciiFilter::setEndRow(const int r) {
 	d->endRow = r;
 }
 int AsciiFilter::endRow() const {
 	return d->endRow;
 }
 
 void AsciiFilter::setStartColumn(const int c) {
 	d->startColumn = c;
 }
 int AsciiFilter::startColumn() const {
 	return d->startColumn;
 }
 
 void AsciiFilter::setEndColumn(const int c) {
 	d->endColumn = c;
 }
 int AsciiFilter::endColumn() const {
 	return d->endColumn;
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 AsciiFilterPrivate::AsciiFilterPrivate(AsciiFilter* owner) : q(owner),
 	commentCharacter("#"),
 	separatingCharacter("auto"),
 	numberFormat(QLocale::C),
 	autoModeEnabled(true),
 	headerEnabled(true),
 	skipEmptyParts(false),
 	simplifyWhitespacesEnabled(true),
 	nanValue(NAN),
 	removeQuotesEnabled(false),
 	createIndexEnabled(false),
 	startRow(1),
 	endRow(-1),
 	startColumn(1),
 	endColumn(-1),
 	mqttPreviewFirstEmptyColCount (0),
 	m_actualStartRow(1),
 	m_actualRows(0),
 	m_actualCols(0),
 	m_prepared(false),	
 	m_columnOffset(0) {
 }
 
 /*!
  * get a single line from device
  */
 QStringList AsciiFilterPrivate::getLineString(QIODevice& device) {
 	QString line;
 	do {	// skip comment lines in data lines
 		if (!device.canReadLine())
 			DEBUG("WARNING in AsciiFilterPrivate::getLineString(): device cannot 'readLine()' but using it anyway.");
 //			line = device.readAll();
 		line = device.readLine();
 	} while (line.startsWith(commentCharacter));
 
 	line.remove(QRegExp("[\\n\\r]"));	// remove any newline
 	if (simplifyWhitespacesEnabled)
 		line = line.simplified();
 	DEBUG("data line : \'" << line.toStdString() << '\'');
 	QStringList lineStringList = line.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 	//TODO: remove quotes here?
 	QDEBUG("data line, parsed: " << lineStringList);
 
 	return lineStringList;
 }
 
 /*!
  * returns -1 if the device couldn't be opened, 1 if the current read position in the device is at the end and 0 otherwise.
  */
 int AsciiFilterPrivate::prepareDeviceToRead(QIODevice& device) {
 	DEBUG("AsciiFilterPrivate::prepareDeviceToRead(): is sequential = " << device.isSequential() << ", can readLine = " << device.canReadLine());
 
     if (!device.open(QIODevice::ReadOnly))
 		return -1;
 
 	if (device.atEnd() && !device.isSequential()) // empty file
 		return 1;
 
 /////////////////////////////////////////////////////////////////
 	// Find first data line (ignoring comment lines)
 	DEBUG("	Skipping " << startRow - 1 << " lines");
 	for (int i = 0; i < startRow - 1; ++i) {
 		QString line;
 		if (!device.canReadLine())
 			DEBUG("WARNING in AsciiFilterPrivate::prepareDeviceToRead(): device cannot 'readLine()' but using it anyway.");
 		line = device.readLine();
 		DEBUG("	line = " << line.toStdString());
 
 		if (device.atEnd()) {
 			if (device.isSequential())
 				break;
 			else
 				return 1;
 		}
 	}
 
 	// Parse the first line:
 	// Determine the number of columns, create the columns and use (if selected) the first row to name them
 	QString firstLine;
 	do {	// skip comment lines
 		if (!device.canReadLine())
 			DEBUG("WARNING in AsciiFilterPrivate::prepareDeviceToRead(): device cannot 'readLine()' but using it anyway.");
 
 		if (device.atEnd()) {
 			DEBUG("device at end! Giving up.");
 			if (device.isSequential())
 				break;
 			else
 				return 1;
 		}
 
 		firstLine = device.readLine();
 	} while (firstLine.startsWith(commentCharacter));
 
 	DEBUG(" device position after first line and comments = " << device.pos());
 	firstLine.remove(QRegExp("[\\n\\r]"));	// remove any newline
 	if (simplifyWhitespacesEnabled)
 		firstLine = firstLine.simplified();
 	DEBUG("First line: \'" << firstLine.toStdString() << '\'');
 
 	// determine separator and split first line
 	QStringList firstLineStringList;
 	if (separatingCharacter == "auto") {
 		DEBUG("automatic separator");
 		QRegExp regExp("(\\s+)|(,\\s+)|(;\\s+)|(:\\s+)");
 		firstLineStringList = firstLine.split(regExp, (QString::SplitBehavior)skipEmptyParts);
 
 		if (!firstLineStringList.isEmpty()) {
 			int length1 = firstLineStringList.at(0).length();
 			if (firstLineStringList.size() > 1) {
 				int pos2 = firstLine.indexOf(firstLineStringList.at(1), length1);
 				m_separator = firstLine.mid(length1, pos2 - length1);
 			} else {
 				//old: separator = line.right(line.length() - length1);
 				m_separator = ' ';
 			}
 		}
 	} else {	// use given separator
 		// replace symbolic "TAB" with '\t'
 		m_separator = separatingCharacter.replace(QLatin1String("2xTAB"), "\t\t", Qt::CaseInsensitive);
 		m_separator = separatingCharacter.replace(QLatin1String("TAB"), "\t", Qt::CaseInsensitive);
 		// replace symbolic "SPACE" with ' '
 		m_separator = m_separator.replace(QLatin1String("2xSPACE"), QLatin1String("  "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("3xSPACE"), QLatin1String("   "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("4xSPACE"), QLatin1String("    "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("SPACE"), QLatin1String(" "), Qt::CaseInsensitive);
 		firstLineStringList = firstLine.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 	}
 	DEBUG("separator: \'" << m_separator.toStdString() << '\'');
 	DEBUG("number of columns: " << firstLineStringList.size());
 	QDEBUG("first line: " << firstLineStringList);
 	DEBUG("headerEnabled: " << headerEnabled);
 
 	//optionally, remove potential spaces in the first line
 	if (simplifyWhitespacesEnabled) {
 		for (int i = 0; i < firstLineStringList.size(); ++i)
 			firstLineStringList[i] = firstLineStringList[i].simplified();
 	}
 
 	if (headerEnabled) {	// use first line to name vectors
 		vectorNames = firstLineStringList;
 		QDEBUG("vector names =" << vectorNames);
 		m_actualStartRow = startRow + 1;
 	} else
 		m_actualStartRow = startRow;
 
 	// set range to read
 	if (endColumn == -1) {
 		if (headerEnabled || vectorNames.size() == 0)
 			endColumn = firstLineStringList.size(); // last column
 		else
 			//number of vector names provided in the import dialog (not more than the maximal number of columns in the file)
 			endColumn = qMin(vectorNames.size(), firstLineStringList.size());
 	}
 	if (createIndexEnabled) {
 		vectorNames.prepend(i18n("Index"));
 		endColumn++;
 	}
 	m_actualCols = endColumn - startColumn + 1;
 
 //TEST: readline-seek-readline fails
 	/*	qint64 testpos = device.pos();
 		DEBUG("read data line @ pos " << testpos << " : " << device.readLine().toStdString());
 		device.seek(testpos);
 		testpos = device.pos();
 		DEBUG("read data line again @ pos " << testpos << "  : " << device.readLine().toStdString());
 	*/
 /////////////////////////////////////////////////////////////////
 
 	// parse first data line to determine data type for each column
 	if (!device.isSequential())
 		firstLineStringList = getLineString(device);
 
 	columnModes.resize(m_actualCols);
 	int col = 0;
 	if (createIndexEnabled) {
 		columnModes[0] = AbstractColumn::Integer;
 		col = 1;
 	}
 
-	for (auto& valueString: firstLineStringList) { // parse columns available in first data line
+	for (auto& valueString : firstLineStringList) { // parse columns available in first data line
 		if (simplifyWhitespacesEnabled)
 			valueString = valueString.simplified();
 		if (col == m_actualCols)
 			break;
 		columnModes[col++] = AbstractFileFilter::columnMode(valueString, dateTimeFormat, numberFormat);
 	}
 	// parsing more lines to better determine data types
 	for (unsigned int i = 0; i < m_dataTypeLines; ++i) {
 		if (device.atEnd())	// EOF reached
 			break;
 		firstLineStringList = getLineString(device);
 
 		createIndexEnabled ? col = 1 : col = 0;
 
-		for (auto& valueString: firstLineStringList) {
+		for (auto& valueString : firstLineStringList) {
 			if (simplifyWhitespacesEnabled)
 				valueString = valueString.simplified();
 			if (col == m_actualCols)
 				break;
 			AbstractColumn::ColumnMode mode = AbstractFileFilter::columnMode(valueString, dateTimeFormat, numberFormat);
 
 			// numeric: integer -> numeric
 			if (mode == AbstractColumn::Numeric && columnModes[col] == AbstractColumn::Integer)
 				columnModes[col] = mode;
 			// text: non text -> text
 			if (mode == AbstractColumn::Text && columnModes[col] != AbstractColumn::Text)
 				columnModes[col] = mode;
 
 			col++;
 		}
 	}
 	QDEBUG("column modes = " << columnModes);
 
 	// ATTENTION: This resets the position in the device to 0
 	m_actualRows = (int)AsciiFilter::lineNumber(device);
 
 	const int actualEndRow = (endRow == -1 || endRow > m_actualRows) ? m_actualRows : endRow;
 	m_actualRows = actualEndRow - m_actualStartRow + 1;
 
 	DEBUG("start/end column: " << startColumn << ' ' << endColumn);
 	DEBUG("start/end row: " << m_actualStartRow << ' ' << actualEndRow);
 	DEBUG("actual cols/rows (w/o header): " << m_actualCols << ' ' << m_actualRows);
 
 	if (m_actualRows == 0 && !device.isSequential())
 		return 1;
 
 	return 0;
 }
 
 /*!
     reads the content of the file \c fileName to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void AsciiFilterPrivate::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode) {
 	DEBUG("AsciiFilterPrivate::readDataFromFile(): fileName = \'" << fileName.toStdString() << "\', dataSource = "
 	      << dataSource << ", mode = " << ENUM_TO_STRING(AbstractFileFilter, ImportMode, importMode));
 
 	KFilterDev device(fileName);
 	readDataFromDevice(device, dataSource, importMode);
 }
 
 qint64 AsciiFilterPrivate::readFromLiveDevice(QIODevice& device, AbstractDataSource* dataSource, qint64 from) {
 	DEBUG("AsciiFilterPrivate::readFromLiveDevice(): bytes available = " << device.bytesAvailable() << ", from = " << from);
 	if (device.bytesAvailable() <= 0) {
 		DEBUG("	No new data available");
 		return 0;
 	}
 
 	//TODO: may be also a matrix?
 	LiveDataSource* spreadsheet = dynamic_cast<LiveDataSource*>(dataSource);
 
 	if (spreadsheet->sourceType() != LiveDataSource::SourceType::FileOrPipe)
 		if (device.isSequential() && device.bytesAvailable() < (int)sizeof(quint16))
 			return 0;
 
 	if (!m_prepared) {
 		DEBUG("	Preparing ..");
 
 		switch (spreadsheet->sourceType()) {
 		case LiveDataSource::SourceType::FileOrPipe: {
 			const int deviceError = prepareDeviceToRead(device);
 			if (deviceError != 0) {
 				DEBUG("	Device error = " << deviceError);
 				return 0;
 			}
 			break;
 		}
 		case LiveDataSource::SourceType::NetworkTcpSocket:
 		case LiveDataSource::SourceType::NetworkUdpSocket:
 		case LiveDataSource::SourceType::LocalSocket:
 		case LiveDataSource::SourceType::SerialPort:
 			m_actualRows = 1;
 			if (createIndexEnabled) {
 				m_actualCols = 2;
 				columnModes << AbstractColumn::Integer << AbstractColumn::Numeric;
 				vectorNames << i18n("Index") << i18n("Value");
 			} else {
 				m_actualCols = 1;
 				columnModes << AbstractColumn::Numeric;
 				vectorNames << i18n("Value");
 			}
 			QDEBUG("	vector names = " << vectorNames);
 		case LiveDataSource::SourceType::MQTT:
 			break;
 		}
 
 		// prepare import for spreadsheet
 		spreadsheet->setUndoAware(false);
 		spreadsheet->resize(AbstractFileFilter::Replace, vectorNames, m_actualCols);
 		DEBUG("	data source resized to col: " << m_actualCols);
 		DEBUG("	data source rowCount: " << spreadsheet->rowCount());
 
 		//columns in a file data source don't have any manual changes.
 		//make the available columns undo unaware and suppress the "data changed" signal.
 		//data changes will be propagated via an explicit Column::setChanged() call once new data was read.
 		for (int i = 0; i < spreadsheet->childCount<Column>(); i++) {
 			spreadsheet->child<Column>(i)->setUndoAware(false);
 			spreadsheet->child<Column>(i)->setSuppressDataChangedSignal(true);
 		}
 
 		int keepNValues = spreadsheet->keepNValues();
 		if (keepNValues == 0)
 			spreadsheet->setRowCount(m_actualRows > 1 ? m_actualRows : 1);
 		else {
 			spreadsheet->setRowCount(keepNValues);
 			m_actualRows = keepNValues;
 		}
 
 		m_dataContainer.resize(m_actualCols);
 
 		DEBUG("	Setting data ..");
 		for (int n = 0; n < m_actualCols; ++n) {
 			// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 			spreadsheet->child<Column>(n)->setColumnMode(columnModes[n]);
 			switch (columnModes[n]) {
 			case AbstractColumn::Numeric: {
 				QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Text: {
 				QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			//TODO
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 		}
 
 		DEBUG("	Prepared!");
 	}
 
 	qint64 bytesread = 0;
 
 #ifdef PERFTRACE_LIVE_IMPORT
 	PERFTRACE("AsciiLiveDataImportTotal: ");
 #endif
 	LiveDataSource::ReadingType readingType;
 	if (!m_prepared) {
 		readingType = LiveDataSource::ReadingType::TillEnd;
 	} else {
 		//we have to read all the data when reading from end
 		//so we set readingType to TillEnd
 		if (spreadsheet->readingType() == LiveDataSource::ReadingType::FromEnd)
 			readingType = LiveDataSource::ReadingType::TillEnd;
 		//if we read the whole file we just start from the beginning of it
 		//and read till end
 		else if (spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile)
 			readingType = LiveDataSource::ReadingType::TillEnd;
 		else
 			readingType = spreadsheet->readingType();
 	}
 	DEBUG("	Reading type = " << ENUM_TO_STRING(LiveDataSource, ReadingType, readingType));
 
 	//move to the last read position, from == total bytes read
 	//since the other source types are sequential we cannot seek on them
 	if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe)
 		device.seek(from);
 
 	//count the new lines, increase actualrows on each
 	//now we read all the new lines, if we want to use sample rate
 	//then here we can do it, if we have actually sample rate number of lines :-?
 	int newLinesForSampleSizeNotTillEnd = 0;
 	int newLinesTillEnd = 0;
 	QVector<QString> newData;
 	if (readingType != LiveDataSource::ReadingType::TillEnd)
 		newData.resize(spreadsheet->sampleSize());
 
 	int newDataIdx = 0;
 	{
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportReadingFromFile: ");
 #endif
 		DEBUG("	source type = " << ENUM_TO_STRING(LiveDataSource, SourceType, spreadsheet->sourceType()));
 		while (!device.atEnd()) {
 			if (readingType != LiveDataSource::ReadingType::TillEnd) {
 				switch (spreadsheet->sourceType()) {	// different sources need different read methods
 				case LiveDataSource::SourceType::LocalSocket:
 					newData[newDataIdx++] = device.readAll();
 					break;
 				case LiveDataSource::SourceType::NetworkUdpSocket:
 					newData[newDataIdx++] = device.read(device.bytesAvailable());
 					break;
 				case LiveDataSource::SourceType::FileOrPipe:
 					newData.push_back(device.readLine());
 					break;
 				case LiveDataSource::SourceType::NetworkTcpSocket:
 				//TODO: check serial port
 				case LiveDataSource::SourceType::SerialPort:
 					newData[newDataIdx++] = device.read(device.bytesAvailable());
 				case LiveDataSource::SourceType::MQTT:
 					break;
 				}
 			} else {	// ReadingType::TillEnd
 				switch (spreadsheet->sourceType()) {	// different sources need different read methods
 				case LiveDataSource::SourceType::LocalSocket:
 					newData.push_back(device.readAll());
 					break;
 				case LiveDataSource::SourceType::NetworkUdpSocket:
 					newData.push_back(device.read(device.bytesAvailable()));
 					break;
 				case LiveDataSource::SourceType::FileOrPipe:
 					newData.push_back(device.readLine());
 					break;
 				case LiveDataSource::SourceType::NetworkTcpSocket:
 				//TODO: check serial port
 				case LiveDataSource::SourceType::SerialPort:
 					newData.push_back(device.read(device.bytesAvailable()));
 				case LiveDataSource::SourceType::MQTT:
 					break;
 				}
 			}
 			newLinesTillEnd++;
 
 			if (readingType != LiveDataSource::ReadingType::TillEnd) {
 				newLinesForSampleSizeNotTillEnd++;
 				//for Continuous reading and FromEnd we read sample rate number of lines if possible
 				//here TillEnd and Whole file behave the same
 				if (newLinesForSampleSizeNotTillEnd == spreadsheet->sampleSize())
 					break;
 			}
 		}
 		QDEBUG("	data read: " << newData);
 	}
 	//now we reset the readingType
 	if (spreadsheet->readingType() == LiveDataSource::ReadingType::FromEnd)
 		readingType = spreadsheet->readingType();
 
 	//we had less new lines than the sample size specified
 	if (readingType != LiveDataSource::ReadingType::TillEnd)
 		QDEBUG("	Removed empty lines: " << newData.removeAll(""));
 
 	//back to the last read position before counting when reading from files
 	if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe)
 		device.seek(from);
 
 	const int spreadsheetRowCountBeforeResize = spreadsheet->rowCount();
 
 	int currentRow = 0; // indexes the position in the vector(column)
 	int linesToRead = 0;
 	int keepNValues = spreadsheet->keepNValues();
 
 	DEBUG("	Increase row count. keepNValues = " << keepNValues);
 	if (m_prepared) {
 		//increase row count if we don't have a fixed size
 		//but only after the preparation step
 		if (keepNValues == 0) {
 			DEBUG("	keep All values");
 			if (readingType != LiveDataSource::ReadingType::TillEnd)
 				m_actualRows += qMin(newData.size(), spreadsheet->sampleSize());
 			else {
 				//we don't increase it if we reread the whole file, we reset it
 				if (!(spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile))
 					m_actualRows += newData.size();
 				else
 					m_actualRows = newData.size();
 			}
 
 			//appending
 			if (spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile)
 				linesToRead = m_actualRows;
 			else
 				linesToRead = m_actualRows - spreadsheetRowCountBeforeResize;
 		} else {	// fixed size
 			DEBUG("	keep " << keepNValues << " values");
 			if (readingType == LiveDataSource::ReadingType::TillEnd) {
 				//we had more lines than the fixed size, so we read m_actualRows number of lines
 				if (newLinesTillEnd > m_actualRows) {
 					linesToRead = m_actualRows;
 					//TODO after reading we should skip the next data lines
 					//because it's TillEnd actually
 				} else
 					linesToRead = newLinesTillEnd;
 			} else {
 				//we read max sample size number of lines when the reading mode
 				//is ContinuouslyFixed or FromEnd, WholeFile is disabled
 				linesToRead = qMin(spreadsheet->sampleSize(), newLinesTillEnd);
 			}
 		}
 		DEBUG("	actual rows = " << m_actualRows);
 
 		if (linesToRead == 0)
 			return 0;
 	} else {	// not prepared
 		linesToRead = newLinesTillEnd;
 		if (headerEnabled)
 			--m_actualRows;
 	}
 	DEBUG("	lines to read = " << linesToRead);
 
 	if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe || spreadsheet->sourceType() == LiveDataSource::SourceType::NetworkUdpSocket) {
 		if (m_actualRows < linesToRead) {
 			DEBUG("	SET lines to read to " << m_actualRows);
 			linesToRead = m_actualRows;
 		}
 	}
 
 	//new rows/resize columns if we don't have a fixed size
 	//TODO if the user changes this value..m_resizedToFixedSize..setResizedToFixedSize
 	if (keepNValues == 0) {
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportResizing: ");
 #endif
 		if (spreadsheet->rowCount() < m_actualRows)
 			spreadsheet->setRowCount(m_actualRows);
 
 		if (!m_prepared)
 			currentRow = 0;
 		else {
 			// indexes the position in the vector(column)
 			if (spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile)
 				currentRow = 0;
 			else
 				currentRow = spreadsheetRowCountBeforeResize;
 		}
 
 		// if we have fixed size, we do this only once in preparation, here we can use
 		// m_prepared and we need something to decide whether it has a fixed size or increasing
 		for (int n = 0; n < m_actualCols; ++n) {
 			// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 			switch (columnModes[n]) {
 			case AbstractColumn::Numeric: {
 				QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Text: {
 				QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(n)->data());
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			//TODO
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 		}
 	} else {	// fixed size
 		//when we have a fixed size we have to pop sampleSize number of lines if specified
 		//here popping, setting currentRow
 		if (!m_prepared) {
 			if (spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile)
 				currentRow = 0;
 			else
 				currentRow = m_actualRows - qMin(newLinesTillEnd, m_actualRows);
 		} else {
 			if (readingType == LiveDataSource::ReadingType::TillEnd) {
 				if (newLinesTillEnd > m_actualRows) {
 					currentRow = 0;
 				} else {
 					if (spreadsheet->readingType() == LiveDataSource::ReadingType::WholeFile)
 						currentRow = 0;
 					else
 						currentRow = m_actualRows - newLinesTillEnd;
 				}
 			} else {
 				//we read max sample size number of lines when the reading mode
 				//is ContinuouslyFixed or FromEnd
 				currentRow = m_actualRows - qMin(spreadsheet->sampleSize(), newLinesTillEnd);
 			}
 		}
 
 		if (m_prepared) {
 #ifdef PERFTRACE_LIVE_IMPORT
 			PERFTRACE("AsciiLiveDataImportPopping: ");
 #endif
 			// enable data change signal
 			for (int col = 0; col < m_actualCols; ++col)
 				spreadsheet->child<Column>(col)->setSuppressDataChangedSignal(false);
 
 			for (int row = 0; row < linesToRead; ++row) {
 				for (int col = 0; col < m_actualCols; ++col) {
 					switch (columnModes[col]) {
 					case AbstractColumn::Numeric: {
 						QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::Integer: {
 						QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::Text: {
 						QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::DateTime: {
 						QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					//TODO
 					case AbstractColumn::Month:
 					case AbstractColumn::Day:
 						break;
 					}
 				}
 			}
 		}
 	}
 
 	// from the last row we read the new data in the spreadsheet
 	DEBUG("	Reading from line "  << currentRow << " till end line " << newLinesTillEnd);
 	DEBUG("	Lines to read:" << linesToRead <<", actual rows:" << m_actualRows << ", actual cols:" << m_actualCols);
 	newDataIdx = 0;
 	if (readingType == LiveDataSource::ReadingType::FromEnd) {
 		if (m_prepared) {
 			if (newData.size() > spreadsheet->sampleSize())
 				newDataIdx = newData.size() - spreadsheet->sampleSize();
 			//since we skip a couple of lines, we need to count those bytes too
 			for (int i = 0; i < newDataIdx; ++i)
 				bytesread += newData.at(i).size();
 		}
 	}
 	DEBUG("	newDataIdx: " << newDataIdx);
 
 	static int indexColumnIdx = 1;
 	{
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportFillingContainers: ");
 #endif
 		int row = 0;
 
 		if (readingType == LiveDataSource::ReadingType::TillEnd || (readingType == LiveDataSource::ReadingType::ContinuousFixed)) {
 			if (headerEnabled) {
 				if (!m_prepared) {
 					row = 1;
 					bytesread += newData.at(0).size();
 				}
 			}
 		}
 		if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe) {
 			if (readingType == LiveDataSource::ReadingType::WholeFile) {
 				if (headerEnabled) {
 					row = 1;
 					bytesread += newData.at(0).size();
 				}
 			}
 		}
 
 		for (; row < linesToRead; ++row) {
 			DEBUG("\n	Reading row " << row + 1 << " of " << linesToRead);
 			QString line;
 			if (readingType == LiveDataSource::ReadingType::FromEnd)
 				line = newData.at(newDataIdx++);
 			else
 				line = newData.at(row);
 			//when we read the whole file we don't care about the previous position
 			//so we don't have to count those bytes
 			if (readingType != LiveDataSource::ReadingType::WholeFile) {
 				if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe) {
 					bytesread += line.size();
 				}
 			}
 
 			DEBUG("	Line bytes: " << line.size() << " line: " << line.toStdString());
 			if (simplifyWhitespacesEnabled)
 				line = line.simplified();
 
 			if (line.isEmpty() || line.startsWith(commentCharacter)) // skip empty or commented lines
 				continue;
 
 			QLocale locale(numberFormat);
 
 			QStringList lineStringList;
 			// only FileOrPipe support multiple columns
 			if (spreadsheet->sourceType() == LiveDataSource::SourceType::FileOrPipe)
 				lineStringList = line.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 			else
 				lineStringList << line;
 			QDEBUG("	line = " << lineStringList << ", separator = \'" << m_separator << "\'");
 
 			if (createIndexEnabled) {
 				if (spreadsheet->keepNValues() == 0)
 					lineStringList.prepend(QString::number(currentRow + 1));
 				else
 					lineStringList.prepend(QString::number(indexColumnIdx++));
 			}
 
 			QDEBUG("	column modes = " << columnModes);
 			for (int n = 0; n < m_actualCols; ++n) {
 				DEBUG("	actual col = " << n);
 				if (n < lineStringList.size()) {
 					QString valueString = lineStringList.at(n);
 					DEBUG("	value string = " << valueString.toStdString());
 
 					// set value depending on data type
 					switch (columnModes[n]) {
 					case AbstractColumn::Numeric: {
 						DEBUG("	Numeric");
 						bool isNumber;
 						const double value = locale.toDouble(valueString, &isNumber);
 						static_cast<QVector<double>*>(m_dataContainer[n])->operator[](currentRow) = (isNumber ? value : nanValue);
 						qDebug() << "dataContainer[" << n << "] size:" << static_cast<QVector<double>*>(m_dataContainer[n])->size();
 						break;
 					}
 					case AbstractColumn::Integer: {
 						DEBUG("	Integer");
 						bool isNumber;
 						const int value = locale.toInt(valueString, &isNumber);
 						DEBUG("	container size = " << m_dataContainer.size() << ", current row = " << currentRow);
 						static_cast<QVector<int>*>(m_dataContainer[n])->operator[](currentRow) = (isNumber ? value : 0);
 						qDebug() << "dataContainer[" << n << "] size:" << static_cast<QVector<int>*>(m_dataContainer[n])->size();
 
 						break;
 					}
 					case AbstractColumn::DateTime: {
 						const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 						static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](currentRow) = valueDateTime.isValid() ? valueDateTime : QDateTime();
 						break;
 					}
 					case AbstractColumn::Text:
 						if (removeQuotesEnabled)
 							valueString.remove(QRegExp("[\"\']"));
 						static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](currentRow) = valueString;
 						break;
 					case AbstractColumn::Month:
 						//TODO
 						break;
 					case AbstractColumn::Day:
 						//TODO
 						break;
 					}
 				} else {
 					DEBUG("	missing columns in this line");
 					switch (columnModes[n]) {
 					case AbstractColumn::Numeric:
 						static_cast<QVector<double>*>(m_dataContainer[n])->operator[](currentRow) = nanValue;
 						break;
 					case AbstractColumn::Integer:
 						static_cast<QVector<int>*>(m_dataContainer[n])->operator[](currentRow) = 0;
 						break;
 					case AbstractColumn::DateTime:
 						static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](currentRow) = QDateTime();
 						break;
 					case AbstractColumn::Text:
 						static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](currentRow) = "";
 						break;
 					case AbstractColumn::Month:
 						//TODO
 						break;
 					case AbstractColumn::Day:
 						//TODO
 						break;
 					}
 				}
 			}
 			currentRow++;
 		}
 	}
 
 	if (m_prepared) {
 		//notify all affected columns and plots about the changes
 		PERFTRACE("AsciiLiveDataImport, notify affected columns and plots");
 		const Project* project = spreadsheet->project();
 		QVector<const XYCurve*> curves = project->children<const XYCurve>(AbstractAspect::Recursive);
 		QVector<CartesianPlot*> plots;
 		for (int n = 0; n < m_actualCols; ++n) {
 			Column* column = spreadsheet->column(n);
 
 			//determine the plots where the column is consumed
-			for (const auto* curve: curves) {
+			for (const auto* curve : curves) {
 				if (curve->xColumn() == column || curve->yColumn() == column) {
 					CartesianPlot* plot = dynamic_cast<CartesianPlot*>(curve->parentAspect());
 					if (plots.indexOf(plot) == -1) {
 						plots << plot;
 						plot->setSuppressDataChangedSignal(true);
 					}
 				}
 			}
 
 			column->setChanged();
 		}
 
 		//loop over all affected plots and retransform them
-		for (auto* plot: plots) {
+		for (auto* plot : plots) {
 			plot->setSuppressDataChangedSignal(false);
 			plot->dataChanged();
 		}
 	}
 
 	m_prepared = true;
 
 	DEBUG("AsciiFilterPrivate::readFromLiveDevice() DONE");
 	return bytesread;
 }
 
 /*!
     reads the content of device \c device to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void AsciiFilterPrivate::readDataFromDevice(QIODevice& device, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	DEBUG("AsciiFilterPrivate::readDataFromDevice(): dataSource = " << dataSource
 	      << ", mode = " << ENUM_TO_STRING(AbstractFileFilter, ImportMode, importMode) << ", lines = " << lines);
 
 	if (!m_prepared) {
 		const int deviceError = prepareDeviceToRead(device);
 		if (deviceError != 0) {
 			DEBUG("Device error = " << deviceError);
 			return;
 		}
 
 		// matrix data has only one column mode (which is not text)
 		if (dynamic_cast<Matrix*>(dataSource)) {
 			auto mode = columnModes[0];
 			if (mode == AbstractColumn::Text)
 				mode = AbstractColumn::Numeric;
-			for (auto& c: columnModes)
+			for (auto& c : columnModes)
 				if (c != mode)
 					c = mode;
 		}
 
 		m_columnOffset = dataSource->prepareImport(m_dataContainer, importMode, m_actualRows, m_actualCols, vectorNames, columnModes);
 		m_prepared = true;
 	}
 
 	DEBUG("locale = " << QLocale::languageToString(numberFormat).toStdString());
 	QLocale locale(numberFormat);
 
 	// Read the data
 	int currentRow = 0;	// indexes the position in the vector(column)
 	if (lines == -1)
 		lines = m_actualRows;
 
 	//skip data lines, if required
 	DEBUG("	Skipping " << m_actualStartRow - 1 << " lines");
 	for (int i = 0; i < m_actualStartRow - 1; ++i)
 		device.readLine();
 
 	DEBUG("	Reading " << qMin(lines, m_actualRows)  << " lines");
 	for (int i = 0; i < qMin(lines, m_actualRows); ++i) {
 		QString line = device.readLine();
 
 		line.remove(QRegExp("[\\n\\r]"));	// remove any newline
 		if (simplifyWhitespacesEnabled)
 			line = line.simplified();
 
 		if (line.isEmpty() || line.startsWith(commentCharacter)) // skip empty or commented lines
 			continue;
 
 		QStringList lineStringList = line.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 
 		// remove left white spaces
 		if (skipEmptyParts) {
 			for (int n = 0; n < lineStringList.size(); ++n) {
 				QString valueString = lineStringList.at(n);
 				if (!QString::compare(valueString, " ")) {
 					lineStringList.removeAt(n);
 					n--;
 				}
 			}
 		}
 
 		for (int n = 0; n < m_actualCols; ++n) {
 			// index column if required
 			if (n == 0 && createIndexEnabled) {
 				static_cast<QVector<int>*>(m_dataContainer[0])->operator[](currentRow) = i + 1;
 				continue;
 			}
 
 			if ((createIndexEnabled ? n - 1 : n) < lineStringList.size()) {
 				QString valueString = lineStringList.at(createIndexEnabled ? n - 1 : n);
 
 				// set value depending on data type
 				switch (columnModes[n]) {
 				case AbstractColumn::Numeric: {
 					bool isNumber;
 					const double value = locale.toDouble(valueString, &isNumber);
 					static_cast<QVector<double>*>(m_dataContainer[n])->operator[](currentRow) = (isNumber ? value : nanValue);
 					break;
 				}
 				case AbstractColumn::Integer: {
 					bool isNumber;
 					const int value = locale.toInt(valueString, &isNumber);
 					static_cast<QVector<int>*>(m_dataContainer[n])->operator[](currentRow) = (isNumber ? value : 0);
 					break;
 				}
 				case AbstractColumn::DateTime: {
 					const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 					static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](currentRow) = valueDateTime.isValid() ? valueDateTime : QDateTime();
 					break;
 				}
 				case AbstractColumn::Text:
 					if (removeQuotesEnabled)
 						valueString.remove(QRegExp("[\"\']"));
 					static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](currentRow) = valueString;
 					break;
 				case AbstractColumn::Month:	// never happens
 				case AbstractColumn::Day:
 					break;
 				}
 			} else {	// missing columns in this line
 				switch (columnModes[n]) {
 				case AbstractColumn::Numeric:
 					static_cast<QVector<double>*>(m_dataContainer[n])->operator[](currentRow) = nanValue;
 					break;
 				case AbstractColumn::Integer:
 					static_cast<QVector<int>*>(m_dataContainer[n])->operator[](currentRow) = 0;
 					break;
 				case AbstractColumn::DateTime:
 					static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](currentRow) = QDateTime();
 					break;
 				case AbstractColumn::Text:
 					static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](currentRow) = "";
 					break;
 				case AbstractColumn::Month:	// never happens
 				case AbstractColumn::Day:
 					break;
 				}
 			}
 		}
 
 		currentRow++;
 		emit q->completed(100 * currentRow/m_actualRows);
 	}
 	DEBUG("	Read " << currentRow << " lines");
 
 	dataSource->finalizeImport(m_columnOffset, startColumn, endColumn, currentRow, dateTimeFormat, importMode);
 }
 
 /*!
  * preview for special devices (local/UDP/TCP socket or serial port)
  */
 QVector<QStringList> AsciiFilterPrivate::preview(QIODevice &device) {
 	DEBUG("AsciiFilterPrivate::preview(): bytesAvailable = " << device.bytesAvailable() << ", isSequential = " << device.isSequential());
 	QVector<QStringList> dataStrings;
 
 	if (!(device.bytesAvailable() > 0)) {
 		DEBUG("No new data available");
 		return dataStrings;
 	}
 
 	if (device.isSequential() && device.bytesAvailable() < (int)sizeof(quint16))
 		return dataStrings;
 
 #ifdef PERFTRACE_LIVE_IMPORT
 	PERFTRACE("AsciiLiveDataImportTotal: ");
 #endif
 
 	int linesToRead = 0;
 	QVector<QString> newData;
 
 	//TODO: serial port "read(nBytes)"?
 	while (!device.atEnd()) {
 		if (device.canReadLine())
 			newData.push_back(device.readLine());
 		else	// UDP fails otherwise
 			newData.push_back(device.readAll());
 		linesToRead++;
 	}
 	QDEBUG("	data = " << newData);
 
 	if (linesToRead == 0) return dataStrings;
 
 	int col = 0;
 	int colMax = newData.at(0).size();
 	if (createIndexEnabled)
 		colMax++;
 	columnModes.resize(colMax);
 	if (createIndexEnabled) {
 		columnModes[0] = AbstractColumn::ColumnMode::Integer;
 		col = 1;
 		vectorNames.prepend(i18n("Index"));
 	}
 	vectorNames.append(i18n("Value"));
 	QDEBUG("	vector names = " << vectorNames);
 
-	for (const auto& valueString: newData.at(0).split(' ', QString::SkipEmptyParts)) {
+	for (const auto& valueString : newData.at(0).split(' ', QString::SkipEmptyParts)) {
 		if (col == colMax)
 			break;
 		columnModes[col++] = AbstractFileFilter::columnMode(valueString, dateTimeFormat, numberFormat);
 	}
 
 	for (int i = 0; i < linesToRead; ++i) {
 		QString line = newData.at(i);
 
 		if (simplifyWhitespacesEnabled)
 			line = line.simplified();
 
 		if (line.isEmpty() || line.startsWith(commentCharacter)) // skip empty or commented lines
 			continue;
 
 		QLocale locale(numberFormat);
 
 		QStringList lineStringList = line.split(' ', QString::SkipEmptyParts);
 		if (createIndexEnabled)
 			lineStringList.prepend(QString::number(i + 1));
 
 		QStringList lineString;
 		for (int n = 0; n < lineStringList.size(); ++n) {
 			if (n < lineStringList.size()) {
 				QString valueString = lineStringList.at(n);
 
 				switch (columnModes[n]) {
 				case AbstractColumn::Numeric: {
 					bool isNumber;
 					const double value = locale.toDouble(valueString, &isNumber);
 					lineString += QString::number(isNumber ? value : nanValue, 'g', 16);
 					break;
 				}
 				case AbstractColumn::Integer: {
 					bool isNumber;
 					const int value = locale.toInt(valueString, &isNumber);
 					lineString += QString::number(isNumber ? value : 0);
 					break;
 				}
 				case AbstractColumn::DateTime: {
 					const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 					lineString += valueDateTime.isValid() ? valueDateTime.toString(dateTimeFormat) : QLatin1String(" ");
 					break;
 				}
 				case AbstractColumn::Text:
 					if (removeQuotesEnabled)
 						valueString.remove(QRegExp("[\"\']"));
 					lineString += valueString;
 					break;
 				case AbstractColumn::Month:	// never happens
 				case AbstractColumn::Day:
 					break;
 				}
 			} else 	// missing columns in this line
 				lineString += QLatin1String("");
 		}
 		dataStrings << lineString;
 	}
 
 	return dataStrings;
 }
 
 /*!
  * generates the preview for the file \c fileName reading the provided number of \c lines.
  */
 QVector<QStringList> AsciiFilterPrivate::preview(const QString& fileName, int lines) {
 	QVector<QStringList> dataStrings;
 
 	KFilterDev device(fileName);
 	const int deviceError = prepareDeviceToRead(device);
 	if (deviceError != 0) {
 		DEBUG("Device error = " << deviceError);
 		return dataStrings;
 	}
 
 	//number formatting
 	DEBUG("locale = " << QLocale::languageToString(numberFormat).toStdString());
 	QLocale locale(numberFormat);
 
 	// Read the data
 	if (lines == -1)
 		lines = m_actualRows;
 
 	// set column names for preview
 	if (!headerEnabled) {
 		int start = 0;
 		if (createIndexEnabled)
 			start = 1;
 		for (int i = start; i < m_actualCols; i++)
 				vectorNames << "Column " + QString::number(i + 1);
 	}
 	QDEBUG("	column names = " << vectorNames);
 
 	//skip data lines, if required
 	DEBUG("	Skipping " << m_actualStartRow - 1 << " lines");
 	for (int i = 0; i < m_actualStartRow - 1; ++i)
 		device.readLine();
 
 	DEBUG("	Generating preview for " << qMin(lines, m_actualRows)  << " lines");
 	for (int i = 0; i < qMin(lines, m_actualRows); ++i) {
 		QString line = device.readLine();
 
 		line.remove(QRegExp("[\\n\\r]"));	// remove any newline
 		if (simplifyWhitespacesEnabled)
 			line = line.simplified();
 
 		if (line.isEmpty() || line.startsWith(commentCharacter)) // skip empty or commented lines
 			continue;
 
 
 		QStringList lineStringList = line.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 		QDEBUG(" line = " << lineStringList);
 
 		QStringList lineString;
 		for (int n = 0; n < m_actualCols; ++n) {
 			// index column if required
 			if (n == 0 && createIndexEnabled) {
 				lineString += QString::number(i + 1);
 				continue;
 			}
 
 			if ((createIndexEnabled ? n - 1 : n) < lineStringList.size()) {
 				QString valueString = lineStringList.at(createIndexEnabled ? n - 1 : n);
 				//DEBUG(" valueString = " << valueString.toStdString());
 				if (skipEmptyParts && !QString::compare(valueString, " "))	// handle left white spaces
 					continue;
 
 				// set value depending on data type
 				switch (columnModes[n]) {
 				case AbstractColumn::Numeric: {
 					bool isNumber;
 					const double value = locale.toDouble(valueString, &isNumber);
 					lineString += QString::number(isNumber ? value : nanValue, 'g', 15);
 					break;
 				}
 				case AbstractColumn::Integer: {
 					bool isNumber;
 					const int value = locale.toInt(valueString, &isNumber);
 					lineString += QString::number(isNumber ? value : 0);
 					break;
 				}
 				case AbstractColumn::DateTime: {
 					const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 					lineString += valueDateTime.isValid() ? valueDateTime.toString(dateTimeFormat) : QLatin1String(" ");
 					break;
 				}
 				case AbstractColumn::Text:
 					if (removeQuotesEnabled)
 						valueString.remove(QRegExp("[\"\']"));
 					lineString += valueString;
 					break;
 				case AbstractColumn::Month:	// never happens
 				case AbstractColumn::Day:
 					break;
 				}
 			} else 	// missing columns in this line
 				lineString += QLatin1String("");
 		}
 
 		dataStrings << lineString;
 	}
 
 	return dataStrings;
 }
 
 /*!
     writes the content of \c dataSource to the file \c fileName.
 */
 void AsciiFilterPrivate::write(const QString & fileName, AbstractDataSource* dataSource) {
 	Q_UNUSED(fileName);
 	Q_UNUSED(dataSource);
 
 	//TODO: save data to ascii file
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 /*!
   Saves as XML.
  */
 void AsciiFilter::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement( "asciiFilter");
 	writer->writeAttribute( "commentCharacter", d->commentCharacter);
 	writer->writeAttribute( "separatingCharacter", d->separatingCharacter);
 	writer->writeAttribute( "autoMode", QString::number(d->autoModeEnabled));
 	writer->writeAttribute( "createIndex", QString::number(d->createIndexEnabled));
 	writer->writeAttribute( "header", QString::number(d->headerEnabled));
 	writer->writeAttribute( "vectorNames", d->vectorNames.join(' '));
 	writer->writeAttribute( "skipEmptyParts", QString::number(d->skipEmptyParts));
 	writer->writeAttribute( "simplifyWhitespaces", QString::number(d->simplifyWhitespacesEnabled));
 	writer->writeAttribute( "nanValue", QString::number(d->nanValue));
 	writer->writeAttribute( "removeQuotes", QString::number(d->removeQuotesEnabled));
 	writer->writeAttribute( "startRow", QString::number(d->startRow));
 	writer->writeAttribute( "endRow", QString::number(d->endRow));
 	writer->writeAttribute( "startColumn", QString::number(d->startColumn));
 	writer->writeAttribute( "endColumn", QString::number(d->endColumn));
 
 	writer->writeEndElement();
 }
 
 /*!
   Loads from XML.
 */
 bool AsciiFilter::load(XmlStreamReader* reader) {
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs = reader->attributes();
 
 	QString str = attribs.value("commentCharacter").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("commentCharacter").toString());
 	else
 		d->commentCharacter = str;
 
 	str = attribs.value("separatingCharacter").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("separatingCharacter").toString());
 	else
 		d->separatingCharacter = str;
 
 	str = attribs.value("createIndex").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("createIndex").toString());
 	else
 		d->createIndexEnabled = str.toInt();
 
 	str = attribs.value("autoMode").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("autoMode").toString());
 	else
 		d->autoModeEnabled = str.toInt();
 
 	str = attribs.value("header").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("header").toString());
 	else
 		d->headerEnabled = str.toInt();
 
 	str = attribs.value("vectorNames").toString();
 	d->vectorNames = str.split(' '); //may be empty
 
 	str = attribs.value("simplifyWhitespaces").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("simplifyWhitespaces").toString());
 	else
 		d->simplifyWhitespacesEnabled = str.toInt();
 
 	str = attribs.value("nanValue").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("nanValue").toString());
 	else
 		d->nanValue = str.toDouble();
 
 	str = attribs.value("removeQuotes").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("removeQuotes").toString());
 	else
 		d->removeQuotesEnabled = str.toInt();
 
 	str = attribs.value("skipEmptyParts").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("skipEmptyParts").toString());
 	else
 		d->skipEmptyParts = str.toInt();
 
 	str = attribs.value("startRow").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("startRow").toString());
 	else
 		d->startRow = str.toInt();
 
 	str = attribs.value("endRow").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("endRow").toString());
 	else
 		d->endRow = str.toInt();
 
 	str = attribs.value("startColumn").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("startColumn").toString());
 	else
 		d->startColumn = str.toInt();
 
 	str = attribs.value("endColumn").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.subs("endColumn").toString());
 	else
 		d->endColumn = str.toInt();
 
 	return true;
 }
 
 int AsciiFilterPrivate::isPrepared() {
     return m_prepared;
 }
 
 #ifdef HAVE_MQTT
 
 /*!
  * \brief Offers a preview about the data received by the topic
  * \param list
  * \param message
  * \param topic
  */
 void AsciiFilterPrivate::MQTTPreview(QVector<QStringList>& list, const QString& message, const QString& topic) {
 	QVector<QStringList> dataStrings;
 
 	if (!message.isEmpty()) {
 		qDebug()<<"ascii mqtt preview for: " << topic;
 
 		//check how many lines can be read
 		int linesToRead = 0;
 		QVector<QString> newData;
 		QStringList newDataList = message.split(QRegExp("\n|\r\n|\r"), QString::SkipEmptyParts);
-		for (auto& valueString: newDataList) {
+		for (auto& valueString : newDataList) {
 			QStringList splitString = valueString.split(' ', QString::SkipEmptyParts);
-			for ( const auto& valueString2: splitString) {
+			for (const auto& valueString2 : splitString) {
 				if (!valueString2.isEmpty() && !valueString2.startsWith(commentCharacter) ) {
 					linesToRead++;
 					newData.push_back(valueString2);
 				}
 			}
 		}
 		qDebug() <<" data investigated, lines to read: "<<linesToRead;
 
 		//if no lines can be read, then we don't modify the list
 		if (linesToRead == 0) {
 			//list = dataStrings;
 			return;
 		}
 
 		if(!list.isEmpty()) {
 			//if lines to read is smaller then the size of the list, we shrink the list
 			if(linesToRead < list.size()) {
 				int oldSize = list.size();
 				for(int i = 0; i < oldSize - linesToRead; ++i)
 					list.removeLast();
 			}
 			//otherwise we will only read until the size of the list
 			else if (linesToRead > list.size()) {
 				linesToRead = list.size();
 			}
 		}
 
 		//Determine the number of columns
 		int colSize = 0;
 		if(list.isEmpty()) {
 			if (createIndexEnabled)
 				colSize = 2;
 			else colSize = 1;
 		}
 		else
 			colSize = columnModes.size() + 1;
 
 		columnModes.resize(colSize);
 
 		//if this is the first topic, we check if index has to be added
 		if(list.isEmpty())
 			if (createIndexEnabled) {
 				columnModes[0] = AbstractColumn::ColumnMode::Integer;
 				vectorNames.prepend("index");
 			}
 
 		vectorNames.append( topic);
 		//Set the column mode for the topic
 		columnModes[colSize - 1] = AbstractFileFilter::columnMode(newData[0], dateTimeFormat, numberFormat);
 
 		//improve the column mode, based on the rest of the data
 		for(int i = 0; i < linesToRead; i++) {
 			QString tempLine = newData[i];
 			if (simplifyWhitespacesEnabled)
 				tempLine = tempLine.simplified();
 			AbstractColumn::ColumnMode mode = AbstractFileFilter::columnMode(tempLine, dateTimeFormat, numberFormat);
 
 			// numeric: integer -> numeric
 			if (mode == AbstractColumn::Numeric && columnModes[colSize - 1] == AbstractColumn::Integer) {
 				columnModes[colSize - 1] = mode;
 			}
 			// text: non text -> text
 			if ( (mode == AbstractColumn::Text) && (columnModes[colSize - 1] != AbstractColumn::Text) ) {
 				columnModes[colSize - 1] = mode;
 			}
 		}
 		int forStart = 0;
 		int forEnd = 0;
 
 		if (list.isEmpty()) {
 			forStart = 0;
 			forEnd = linesToRead;
 		}
 		else {
 			if (mqttPreviewFirstEmptyColCount == 0) {
 				dataStrings = list;
 				forStart = 0;
 				forEnd = dataStrings.size();
 			}
 			else {
 				forStart = 1;
 				forEnd = linesToRead;
 				dataStrings = list;
 				QLocale locale(numberFormat);
 				//this is the first column having values, after at least 1 empty column
 				//until now only one row was filled with NaN values, so for starters we fill this row with the new value
 				switch (columnModes[colSize - 1]) {
 				case AbstractColumn::Numeric: {
 					bool isNumber;
 					const double value = locale.toDouble(newData[0], &isNumber);
 					dataStrings[0] += QString::number(isNumber ? value : nanValue, 'g', 16);
 					break;
 				}
 				case AbstractColumn::Integer: {
 					bool isNumber;
 					const int value = locale.toInt(newData[0], &isNumber);
 					dataStrings[0]  += QString::number(isNumber ? value : 0);
 					break;
 				}
 				case AbstractColumn::DateTime: {
 					const QDateTime valueDateTime = QDateTime::fromString(newData[0], dateTimeFormat);
 					dataStrings[0]  += valueDateTime.isValid() ? valueDateTime.toString(dateTimeFormat) : QLatin1String(" ");
 					break;
 				}
 				case AbstractColumn::Text:
 					if (removeQuotesEnabled)
 						newData[0].remove(QRegExp("[\"\']"));
 					dataStrings[0]  += newData[0];
 					break;
 				case AbstractColumn::Month:	// never happens
 				case AbstractColumn::Day:
 					break;
 				}
 			}
 		}
 		//We add every forEnd-forStart values to the list
 		for (int i = forStart; i < forEnd; ++i) {
 			QString line = newData[i];
 
 			if (simplifyWhitespacesEnabled)
 				line = line.simplified();
 
 			//skip empty or commented lines
 			if (line.isEmpty() || line.startsWith(commentCharacter))
 				continue;
 
 			QLocale locale(numberFormat);
 
 			QStringList lineString;
 			//We don't have to do any preparation if there were already data containing topics
 			if(!list.isEmpty() &&  mqttPreviewFirstEmptyColCount == 0)
 				lineString = dataStrings[i];
 
 			//Add index if it is the case
 			if(list.isEmpty() || (!list.isEmpty() && mqttPreviewFirstEmptyColCount > 0) )
 				if (createIndexEnabled)
 					lineString += QString::number(i);
 
 			//If this is the first not empty topic, add nan value to all the empty topics before this one
 			if(!list.isEmpty() && mqttPreviewFirstEmptyColCount > 0){
 				for(int j = 0; j < mqttPreviewFirstEmptyColCount; j++) {
 					lineString += QString::number(nanValue, 'g', 16);
 				}
 			}
 
 			//Add the actual value to the topic
 			switch (columnModes[colSize - 1]) {
 			case AbstractColumn::Numeric: {
 				bool isNumber;
 				const double value = locale.toDouble(line, &isNumber);
 				lineString += QString::number(isNumber ? value : nanValue, 'g', 16);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				bool isNumber;
 				const int value = locale.toInt(line, &isNumber);
 				lineString += QString::number(isNumber ? value : 0);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				const QDateTime valueDateTime = QDateTime::fromString(line, dateTimeFormat);
 				lineString += valueDateTime.isValid() ? valueDateTime.toString(dateTimeFormat) : QLatin1String(" ");
 				break;
 			}
 			case AbstractColumn::Text:
 				if (removeQuotesEnabled)
 					line.remove(QRegExp("[\"\']"));
 				lineString += line;
 				break;
 			case AbstractColumn::Month:	// never happens
 			case AbstractColumn::Day:
 				break;
 			}
 			qDebug()<<"column updated with value";
 
 			// if the list was empty, or this is the first not empty topic, we append the new line
 			if(list.isEmpty() || (!list.isEmpty() && mqttPreviewFirstEmptyColCount > 0))
 				dataStrings << lineString;
 			//Otherwise we update the already existing line
 			if (!list.isEmpty() && mqttPreviewFirstEmptyColCount == 0)
 				dataStrings[i] = lineString;
 		}
 		//The first empty topics were taken care of
 		if(mqttPreviewFirstEmptyColCount > 0) {
 			mqttPreviewFirstEmptyColCount = 0;
 		}
 	}
 	//the message is empty and there were only empty messages before this
 	else if (list.isEmpty() || (!list.isEmpty() && mqttPreviewFirstEmptyColCount > 0) ) {
 		//increment the counter
 		mqttPreviewFirstEmptyColCount ++;
 
 		//determine number of columns
 		int colSize;
 		if (mqttPreviewFirstEmptyColCount == 1){
 			if (createIndexEnabled)
 				colSize = 2;
 			else colSize = 1;
 		}
 		else
 			colSize = columnModes.size() + 1;
 		columnModes.resize(colSize);
 
 		//add index if needed
 		if (mqttPreviewFirstEmptyColCount == 1)
 			if (createIndexEnabled) {
 				columnModes[0] = AbstractColumn::ColumnMode::Integer;
 				vectorNames.prepend("index");
 			}
 
 		//Add new column fot the mepty topic
 		vectorNames.append( topic);
 		columnModes[colSize-1] = AbstractColumn::ColumnMode::Numeric;
 
 		//Add a NaN value to the topic's column
 		QStringList lineString;
 		if (mqttPreviewFirstEmptyColCount == 1) {
 			//Add index if needed
 			if(createIndexEnabled)
 				lineString += QString::number(0);
 			lineString += QString::number(nanValue, 'g', 16);
 			//Append since this is the first empty column
 			dataStrings << lineString;
 		}
 		else {
 			//Update the already existing line
 			dataStrings = list;
 			dataStrings[0] += QString::number(nanValue, 'g', 16);
 		}
 	}
 	//The message is empty but there already was a non empty message
 	else if(!list.isEmpty()) {
 		//Append vector name
 		vectorNames.append( topic);
 
 		int colSize = columnModes.size() + 1;
 		columnModes.resize(colSize);
 		columnModes[colSize-1] = AbstractColumn::ColumnMode::Numeric;
 		dataStrings = list;
 		//Add as many NaN values as many lines the list already has
 		for (int i = 0; i < dataStrings.size(); ++i) {
 			dataStrings[i] += QString::number(nanValue, 'g', 16);
 		}
 	}
 	//update the list
 	list = dataStrings;
 }
 
 /*!
  * \brief Returns the statistical data that is needed by the topic for its MQTTClient's will message
  * \param topic
  */
 QString AsciiFilterPrivate::MQTTColumnStatistics(const MQTTTopic* topic) const{
 	Column* tempColumn = topic->child<Column>(m_actualCols - 1);
 	QString statistics;
 
 	QVector<bool> willStatistics = topic->mqttClient()->willStatistics();
 	//Add every statistical data to the string, the flag of which is set true
 	for(int i = 0; i <= willStatistics.size(); i++) {
 		if(willStatistics[i]) {
 			switch (static_cast<MQTTClient::WillStatistics>(i) ) {
 			case MQTTClient::WillStatistics::ArithmeticMean:
 				statistics += QLatin1String("Arithmetic mean: ") + QString::number(tempColumn->statistics().arithmeticMean) + "\n";
 				break;
 			case MQTTClient::WillStatistics::ContraharmonicMean:
 				statistics += QLatin1String("Contraharmonic mean: ") + QString::number(tempColumn->statistics().contraharmonicMean) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Entropy:
 				statistics += QLatin1String("Entropy: ") + QString::number(tempColumn->statistics().entropy) + "\n";
 				break;
 			case MQTTClient::WillStatistics::GeometricMean:
 				statistics += QLatin1String("Geometric mean: ") + QString::number(tempColumn->statistics().geometricMean) + "\n";
 				break;
 			case MQTTClient::WillStatistics::HarmonicMean:
 				statistics += QLatin1String("Harmonic mean: ") + QString::number(tempColumn->statistics().harmonicMean) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Kurtosis:
 				statistics += QLatin1String("Kurtosis: ") + QString::number(tempColumn->statistics().kurtosis) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Maximum:
 				statistics += QLatin1String("Maximum: ") + QString::number(tempColumn->statistics().maximum) + "\n";
 				break;
 			case MQTTClient::WillStatistics::MeanDeviation:
 				statistics += QLatin1String("Mean deviation: ") + QString::number(tempColumn->statistics().meanDeviation) + "\n";
 				break;
 			case MQTTClient::WillStatistics::MeanDeviationAroundMedian:
 				statistics += QLatin1String("Mean deviation around median: ") + QString::number(tempColumn->statistics().meanDeviationAroundMedian) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Median:
 				statistics += QLatin1String("Median: ") + QString::number(tempColumn->statistics().median) + "\n";
 				break;
 			case MQTTClient::WillStatistics::MedianDeviation:
 				statistics += QLatin1String("Median deviation: ") + QString::number(tempColumn->statistics().medianDeviation) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Minimum:
 				statistics += QLatin1String("Minimum: ") + QString::number(tempColumn->statistics().minimum) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Skewness:
 				statistics += QLatin1String("Skewness: ") + QString::number(tempColumn->statistics().skewness) + "\n";
 				break;
 			case MQTTClient::WillStatistics::StandardDeviation:
 				statistics += QLatin1String("Standard deviation: ") + QString::number(tempColumn->statistics().standardDeviation) + "\n";
 				break;
 			case MQTTClient::WillStatistics::Variance:
 				statistics += QLatin1String("Variance: ") + QString::number(tempColumn->statistics().variance) + "\n";
 				break;
 			default:
 				break;
 			}
 		}
 	}
 	return statistics;
 }
 
 AbstractColumn::ColumnMode AsciiFilterPrivate::MQTTColumnMode() const{
 	return columnModes[m_actualCols - 1];
 }
 
 /*!
  * \brief reads the content of a message received by the topic.
  * Uses the settings defined in the MQTTTopic's MQTTClient
  * \param message
  * \param topic
  * \param dataSource
  */
 void AsciiFilterPrivate::readMQTTTopic(const QString& message, const QString& topic, AbstractDataSource*dataSource) {
 	//If the message is empty, there is nothing to do
 	if (message.isEmpty()) {
 		DEBUG("No new data available");
 		return;
 	}
 
 	MQTTTopic* spreadsheet = dynamic_cast<MQTTTopic*>(dataSource);
 
 	int keepNValues = spreadsheet->keepNValues();
 
 	if (!m_prepared) {
 		qDebug()<<"Start preparing filter for: " << spreadsheet->topicName();
 
 		//Prepare the filter
 		const int mqttPrepareError = prepareMQTTTopicToRead(message, topic);
 		if (mqttPrepareError != 0) {
 			DEBUG("Mqtt Prepare Error = " << mqttPrepareError);
 			qDebug()<<mqttPrepareError<<"  itt van baj mqttPrepareError";
 			return;
 		}
 
 		// prepare import for spreadsheet
 		spreadsheet->setUndoAware(false);
 		spreadsheet->resize(AbstractFileFilter::Replace, vectorNames, m_actualCols);
 		qDebug() << "fds resized to col: " << m_actualCols;
 		qDebug() << "fds rowCount: " << spreadsheet->rowCount();
 
 		//columns in a MQTTTopic don't have any manual changes.
 		//make the available columns undo unaware and suppress the "data changed" signal.
 		//data changes will be propagated via an explicit Column::setChanged() call once new data was read.
 		for (int i = 0; i < spreadsheet->childCount<Column>(); i++) {
 			spreadsheet->child<Column>(i)->setUndoAware(false);
 			spreadsheet->child<Column>(i)->setSuppressDataChangedSignal(true);
 		}
 
 		if (keepNValues == 0)
 			spreadsheet->setRowCount(m_actualRows > 1 ? m_actualRows : 1);
 		else {
 			spreadsheet->setRowCount(spreadsheet->keepNValues());
 			m_actualRows = spreadsheet->keepNValues();
 		}
 
 		m_dataContainer.resize(m_actualCols);
 
 		for (int n = 0; n < m_actualCols; ++n) {
 			// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 			spreadsheet->child<Column>(n)->setColumnMode(columnModes[n]);
 			switch (columnModes[n]) {
 			case AbstractColumn::Numeric: {
 				QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Text: {
 				QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 				//TODO
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 		}
 	}
 
 #ifdef PERFTRACE_LIVE_IMPORT
 	PERFTRACE("AsciiLiveDataImportTotal: ");
 #endif
 
 	MQTTClient::ReadingType readingType;
 	if (!m_prepared) {
 		//if filter is not prepared we read till the end
 		readingType = MQTTClient::ReadingType::TillEnd;
 	} else {
 		//we have to read all the data when reading from end
 		//so we set readingType to TillEnd
 		if (spreadsheet->readingType() == MQTTClient::ReadingType::FromEnd) {
 			readingType = MQTTClient::ReadingType::TillEnd;
 		} else {
 			readingType = static_cast<MQTTClient::ReadingType>(spreadsheet->readingType());
 		}
 	}
 
 	//count the new lines, increase actualrows on each
 	//now we read all the new lines, if we want to use sample rate
 	//then here we can do it, if we have actually sample rate number of lines :-?
 	int newLinesForSampleSizeNotTillEnd = 0;
 	int newLinesTillEnd = 0;
 	QVector<QString> newData;
 	if (readingType != MQTTClient::ReadingType::TillEnd) {
 		newData.reserve(spreadsheet->sampleSize());
 		newData.resize(spreadsheet->sampleSize());
 	}
 
 	int newDataIdx = 0;
 	bool sampleSizeReached = false;
 	{
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportReadingFromFile: ");
 #endif
 		QStringList newDataList = message.split(QRegExp("\n|\r\n|\r"), QString::SkipEmptyParts);
-		for (auto& valueString: newDataList) {			
+		for (auto& valueString : newDataList) {			
 			if(!valueString.startsWith(commentCharacter)) {
 
 				QStringList splitString = valueString.split(m_separator, static_cast<QString::SplitBehavior>(skipEmptyParts));
 
-				for (const auto& valueString2: splitString) {
+				for (const auto& valueString2 : splitString) {
 					if (!valueString2.isEmpty() && !valueString2.startsWith(commentCharacter)) {
 
 						if (readingType != MQTTClient::ReadingType::TillEnd)
 							newData[newDataIdx++] = valueString2;
 						else
 							newData.push_back(valueString2);
 						newLinesTillEnd++;
 
 						if (readingType != MQTTClient::ReadingType::TillEnd) {
 							newLinesForSampleSizeNotTillEnd++;
 							//for Continuous reading and FromEnd we read sample rate number of lines if possible
 							if (newLinesForSampleSizeNotTillEnd == spreadsheet->sampleSize()) {
 								sampleSizeReached = true;
 								break;
 							}
 						}
 					}
 				}
 				//if the sample size limit is reached we brake from the outer loop as well
 				if(sampleSizeReached)
 					break;
 			}
 		}
 	}
 
 	qDebug()<<"Processing message done";
 	//now we reset the readingType
 	if (static_cast<MQTTClient::ReadingType>(spreadsheet->readingType()) == MQTTClient::ReadingType::FromEnd)
 		readingType = static_cast<MQTTClient::ReadingType>(spreadsheet->readingType());
 
 	//we had less new lines than the sample rate specified
 	if (readingType != MQTTClient::ReadingType::TillEnd)
 		qDebug() << "Removed empty lines: " << newData.removeAll("");
 
 	qDebug()<<"Create index enabled:  "<<createIndexEnabled;
 
 	const int spreadsheetRowCountBeforeResize = spreadsheet->rowCount();;
 
 	if(m_prepared ) {
 		if (keepNValues == 0)
 			m_actualRows = spreadsheetRowCountBeforeResize;
 		else {
 			//if the keepNValues changed since the last read we have to manage the columns accordingly
 			if(m_actualRows != spreadsheet->keepNValues()) {
 				if(m_actualRows < spreadsheet->keepNValues()) {
 					spreadsheet->setRowCount(spreadsheet->keepNValues());
 					qDebug()<<"rowcount set to: " << spreadsheet->keepNValues();
 				}
 
 				//Calculate the difference between the old and new keepNValues
 				int rowDiff = 0;
 				if(m_actualRows > spreadsheet->keepNValues()) {
 					rowDiff = m_actualRows -  spreadsheet->keepNValues();
 				}
 				if(m_actualRows < spreadsheet->keepNValues()) {
 					rowDiff =spreadsheet->keepNValues() - m_actualRows;
 				}
 
 				for (int n = 0; n < columnModes.size(); ++n) {
 					// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 					switch (columnModes[n]) {
 					case AbstractColumn::Numeric: {
 						QVector<double>*  vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(n)->data());
 						m_dataContainer[n] = static_cast<void *>(vector);
 
 						//if the keepNValues got smaller then we move the last keepNValues count of data
 						//in the first keepNValues places
 						if(m_actualRows > spreadsheet->keepNValues()) {
 							for(int i = 0; i < spreadsheet->keepNValues(); i++) {
 								static_cast<QVector<double>*>(m_dataContainer[n])->operator[] (i) =
 										static_cast<QVector<double>*>(m_dataContainer[n])->operator[](m_actualRows - spreadsheet->keepNValues() + i);
 							}
 						}
 
 						//if the keepNValues got bigger we move the existing values to the last m_actualRows positions
 						//then fill the remaining lines with NaN
 						if(m_actualRows < spreadsheet->keepNValues()) {
 							vector->reserve( spreadsheet->keepNValues());
 							vector->resize( spreadsheet->keepNValues());
 
 							for(int i = 1; i <= m_actualRows; i++) {
 								static_cast<QVector<double>*>(m_dataContainer[n])->operator[] (spreadsheet->keepNValues() - i) =
 										static_cast<QVector<double>*>(m_dataContainer[n])->operator[](spreadsheet->keepNValues() - i - rowDiff);
 							}
 							for(int i = 0; i < rowDiff; i++) {
 								static_cast<QVector<double>*>(m_dataContainer[n])->operator[](i) = nanValue;
 							}
 						}
 						break;
 					}
 					case AbstractColumn::Integer: {
 						QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(n)->data());
 						m_dataContainer[n] = static_cast<void *>(vector);
 
 						//if the keepNValues got smaller then we move the last keepNValues count of data
 						//in the first keepNValues places
 						if(m_actualRows > spreadsheet->keepNValues()) {
 							for(int i = 0; i < spreadsheet->keepNValues(); i++) {
 								static_cast<QVector<int>*>(m_dataContainer[n])->operator[] (i) =
 										static_cast<QVector<int>*>(m_dataContainer[n])->operator[](m_actualRows - spreadsheet->keepNValues() + i);
 							}
 						}
 
 						//if the keepNValues got bigger we move the existing values to the last m_actualRows positions
 						//then fill the remaining lines with 0
 						if(m_actualRows < spreadsheet->keepNValues()) {
 							vector->reserve( spreadsheet->keepNValues());
 							vector->resize( spreadsheet->keepNValues());
 							for(int i = 1; i <= m_actualRows; i++) {
 								static_cast<QVector<int>*>(m_dataContainer[n])->operator[] (spreadsheet->keepNValues() - i) =
 										static_cast<QVector<int>*>(m_dataContainer[n])->operator[](spreadsheet->keepNValues() - i - rowDiff);
 							}
 							for(int i = 0; i < rowDiff; i++){
 								static_cast<QVector<int>*>(m_dataContainer[n])->operator[](i) = 0;
 							}
 						}
 						break;
 					}
 					case AbstractColumn::Text: {
 						QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(n)->data());
 						m_dataContainer[n] = static_cast<void *>(vector);
 
 						//if the keepNValues got smaller then we move the last keepNValues count of data
 						//in the first keepNValues places
 						if(m_actualRows > spreadsheet->keepNValues()) {
 							for(int i = 0; i < spreadsheet->keepNValues(); i++) {
 								static_cast<QVector<QString>*>(m_dataContainer[n])->operator[] (i) =
 										static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](m_actualRows - spreadsheet->keepNValues() + i);
 							}
 						}
 
 						//if the keepNValues got bigger we move the existing values to the last m_actualRows positions
 						//then fill the remaining lines with ""
 						if(m_actualRows < spreadsheet->keepNValues()) {
 							vector->reserve( spreadsheet->keepNValues());
 							vector->resize( spreadsheet->keepNValues());
 							for(int i = 1; i <= m_actualRows; i++) {
 								static_cast<QVector<QString>*>(m_dataContainer[n])->operator[] (spreadsheet->keepNValues() - i) =
 										static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](spreadsheet->keepNValues() - i - rowDiff);
 							}
 							for(int i = 0; i < rowDiff; i++)
 								static_cast<QVector<QString>*>(m_dataContainer[n])->operator[](i) = "";
 						}
 						break;
 					}
 					case AbstractColumn::DateTime: {
 						QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(n)->data());
 						m_dataContainer[n] = static_cast<void *>(vector);
 
 						//if the keepNValues got smaller then we move the last keepNValues count of data
 						//in the first keepNValues places
 						if(m_actualRows > spreadsheet->keepNValues()) {
 							for(int i = 0; i < spreadsheet->keepNValues(); i++) {
 								static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[] (i) =
 										static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](m_actualRows - spreadsheet->keepNValues() + i);
 							}
 						}
 
 						//if the keepNValues got bigger we move the existing values to the last m_actualRows positions
 						//then fill the remaining lines with null datetime
 						if(m_actualRows < spreadsheet->keepNValues()) {
 							vector->reserve( spreadsheet->keepNValues());
 							vector->resize( spreadsheet->keepNValues());
 							for(int i = 1; i <= m_actualRows; i++) {
 								static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[] (spreadsheet->keepNValues() - i) =
 										static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](spreadsheet->keepNValues() - i - rowDiff);
 							}
 							for(int i = 0; i < rowDiff; i++)
 								static_cast<QVector<QDateTime>*>(m_dataContainer[n])->operator[](i) = QDateTime();
 						}
 						break;
 					}
 						//TODO
 					case AbstractColumn::Month:
 					case AbstractColumn::Day:
 						break;
 					}
 				}
 				//if the keepNValues got smaller resize the spreadsheet
 				if(m_actualRows > spreadsheet->keepNValues())
 					spreadsheet->setRowCount(spreadsheet->keepNValues());
 
 				//set the new row count
 				m_actualRows = spreadsheet->keepNValues();
 				qDebug()<<"actual rows: "<<m_actualRows;
 			}
 		}
 	}
 
 	qDebug()<<"starting m_actual rows calculated: " << m_actualRows <<", new data size: "<<newData.size();
 
 	int currentRow = 0; // indexes the position in the vector(column)
 	int linesToRead = 0;
 
 	if (m_prepared) {
 		//increase row count if we don't have a fixed size
 		//but only after the preparation step
 		if (keepNValues == 0) {
 			if (readingType != MQTTClient::ReadingType::TillEnd)
 				m_actualRows += qMin(newData.size(), spreadsheet->sampleSize());
 			else {
 				m_actualRows += newData.size();
 			}
 		}
 
 		//fixed size
 		if (keepNValues != 0) {
 			if (readingType == MQTTClient::ReadingType::TillEnd) {
 				//we had more lines than the fixed size, so we read m_actualRows number of lines
 				if (newLinesTillEnd > m_actualRows) {
 					linesToRead = m_actualRows;
 				} else
 					linesToRead = newLinesTillEnd;
 			} else {
 				//we read max sample size number of lines when the reading mode
 				//is ContinuouslyFixed or FromEnd
 				if(spreadsheet->sampleSize() <= spreadsheet->keepNValues())
 					linesToRead = qMin(spreadsheet->sampleSize(), newLinesTillEnd);
 				else
 					linesToRead = qMin(spreadsheet->keepNValues(), newLinesTillEnd);
 			}
 		} else {
 			linesToRead = m_actualRows - spreadsheetRowCountBeforeResize;
 		}
 
 		if (linesToRead == 0)
 			return;
 
 	} else {
 		if(keepNValues != 0) {
 			linesToRead = newLinesTillEnd > m_actualRows ? m_actualRows : newLinesTillEnd;
 		}
 		else {
 			linesToRead = newLinesTillEnd;
 		}
 	}
 	qDebug()<<"linestoread = " << linesToRead;
 
 	//new rows/resize columns if we don't have a fixed size
 	if (keepNValues == 0) {
 
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportResizing: ");
 #endif
 		if (spreadsheet->rowCount() < m_actualRows)
 			spreadsheet->setRowCount(m_actualRows);
 
 		if (!m_prepared)
 			currentRow = 0;
 		else {
 			// indexes the position in the vector(column)
 			currentRow = spreadsheetRowCountBeforeResize;
 		}
 
 		// if we have fixed size, we do this only once in preparation, here we can use
 		// m_prepared and we need something to decide whether it has a fixed size or increasing
 
 		for (int n = 0; n < m_actualCols; ++n) {
 			// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 			switch (columnModes[n]) {
 			case AbstractColumn::Numeric: {
 				QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Text: {
 				QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 				//TODO
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 		}
 	} else {
 		//when we have a fixed size we have to pop sampleSize number of lines if specified
 		//here popping, setting currentRow
 		if (!m_prepared)
 			currentRow = m_actualRows - qMin(newLinesTillEnd, m_actualRows);
 		else {
 			if (readingType == MQTTClient::ReadingType::TillEnd) {
 				if (newLinesTillEnd > m_actualRows)
 					currentRow = 0;
 				else {
 					currentRow = m_actualRows - newLinesTillEnd;
 				}
 			} else {
 				//we read max sample rate number of lines when the reading mode
 				//is ContinuouslyFixed or FromEnd
 				currentRow = m_actualRows - linesToRead;
 			}
 		}
 
 		if (m_prepared) {
 #ifdef PERFTRACE_LIVE_IMPORT
 			PERFTRACE("AsciiLiveDataImportPopping: ");
 #endif
 			for (int row = 0; row < linesToRead; ++row) {
 				for (int col = 0;  col < m_actualCols; ++col) {
 					switch (columnModes[col]) {
 					case AbstractColumn::Numeric: {
 						QVector<double>* vector = static_cast<QVector<double>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->reserve(m_actualRows);
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::Integer: {
 						QVector<int>* vector = static_cast<QVector<int>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->reserve(m_actualRows);
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::Text: {
 						QVector<QString>* vector = static_cast<QVector<QString>*>(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->reserve(m_actualRows);
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 					case AbstractColumn::DateTime: {
 						QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(spreadsheet->child<Column>(col)->data());
 						vector->pop_front();
 						vector->reserve(m_actualRows);
 						vector->resize(m_actualRows);
 						m_dataContainer[col] = static_cast<void *>(vector);
 						break;
 					}
 						//TODO
 					case AbstractColumn::Month:
 					case AbstractColumn::Day:
 						break;
 					}
 				}
 			}
 		}
 	}
 
 	// from the last row we read the new data in the spreadsheet
 	qDebug() << "reading from line: "  << currentRow << " lines till end: " << newLinesTillEnd;
 	qDebug() << "Lines to read: " << linesToRead <<" actual rows: " << m_actualRows;
 	newDataIdx = 0;
 	//From end means that we read the last sample size amount of data
 	if (readingType == MQTTClient::ReadingType::FromEnd) {
 		if (m_prepared) {
 			if (newData.size() > spreadsheet->sampleSize())
 				newDataIdx = newData.size() - spreadsheet->sampleSize();
 		}
 	}
 
 	qDebug() << "newDataIdx: " << newDataIdx;
 	static int indexColumnIdx = 0;
 	{
 #ifdef PERFTRACE_LIVE_IMPORT
 		PERFTRACE("AsciiLiveDataImportFillingContainers: ");
 #endif
 		int row = 0;
 		for (; row < linesToRead; ++row) {
 			QString line;
 			if (readingType == MQTTClient::ReadingType::FromEnd)
 				line = newData.at(newDataIdx++);
 			else
 				line = newData.at(row);
 
 			if (simplifyWhitespacesEnabled)
 				line = line.simplified();
 
 			if (line.isEmpty() || line.startsWith(commentCharacter))
 			{
 				qDebug()<<"found empty line     "<<currentRow;
 				continue;
 			}
 
 			QLocale locale(numberFormat);
 
 			int col = 0;
 			//Add index if needed
 			if (createIndexEnabled) {
 				col = 1;
 				QString tempIndex;
 				if (keepNValues != 0)
 					tempIndex = QString::number(indexColumnIdx++);
 				else
 					tempIndex = QString::number(currentRow);
 				switch (columnModes[0]) {
 				case AbstractColumn::Numeric: {
 					bool isNumber;
 					const double value = locale.toDouble(tempIndex, &isNumber);
 					static_cast<QVector<double>*>(m_dataContainer[0])->operator[](currentRow) = (isNumber ? value : nanValue);
 					break;
 				}
 				case AbstractColumn::Integer: {
 					bool isNumber;
 					const int value = locale.toInt(tempIndex, &isNumber);
 					static_cast<QVector<int>*>(m_dataContainer[0])->operator[](currentRow) = (isNumber ? value : 0);
 					break;
 				}
 				case AbstractColumn::DateTime: {
 					const QDateTime valueDateTime = QDateTime::fromString(tempIndex, dateTimeFormat);
 					static_cast<QVector<QDateTime>*>(m_dataContainer[0])->operator[](currentRow) = valueDateTime.isValid() ? valueDateTime : QDateTime();
 					break;
 				}
 				case AbstractColumn::Text:
 					if (removeQuotesEnabled)
 						tempIndex.remove(QRegExp("[\"\']"));
 					static_cast<QVector<QString>*>(m_dataContainer[0])->operator[](currentRow) = tempIndex;
 					break;
 				case AbstractColumn::Month:
 					//TODO
 					break;
 				case AbstractColumn::Day:
 					//TODO
 					break;
 				}
 			}
 
 			//setting timestamp on current time
 			static_cast<QVector<QDateTime>*>(m_dataContainer[col])->operator[](currentRow) =  QDateTime::currentDateTime();
 
 			QString valueString = line;
 			qDebug() << "putting in " << valueString << " in line: " << currentRow;
 
 			// set value depending on data type
 			switch (columnModes[m_actualCols - 1]) {
 			case AbstractColumn::Numeric: {
 				bool isNumber;
 				const double value = locale.toDouble(valueString, &isNumber);
 				static_cast<QVector<double>*>(m_dataContainer[m_actualCols - 1])->operator[](currentRow) = (isNumber ? value : nanValue);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				bool isNumber;
 				const int value = locale.toInt(valueString, &isNumber);
 				static_cast<QVector<int>*>(m_dataContainer[m_actualCols - 1])->operator[](currentRow) = (isNumber ? value : 0);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 				static_cast<QVector<QDateTime>*>(m_dataContainer[m_actualCols - 1])->operator[](currentRow) = valueDateTime.isValid() ? valueDateTime : QDateTime();
 				break;
 			}
 			case AbstractColumn::Text:
 				if (removeQuotesEnabled)
 					valueString.remove(QRegExp("[\"\']"));
 				static_cast<QVector<QString>*>(m_dataContainer[m_actualCols - 1])->operator[](currentRow) = valueString;
 				break;
 			case AbstractColumn::Month:
 				//TODO
 				break;
 			case AbstractColumn::Day:
 				//TODO
 				break;
 			}
 
 			currentRow++;
 		}
 	}
 
 	if (m_prepared) {
 		qDebug()<<"notifying plots";
 		//notify all affected columns and plots about the changes
 		PERFTRACE("AsciiLiveDataImport, notify affected columns and plots");
 
 		const Project* project = spreadsheet->project();
 		QVector<const XYCurve*> curves = project->children<const XYCurve>(AbstractAspect::Recursive);
 		QVector<CartesianPlot*> plots;
 
 		qDebug()<<"Uploading plots";
 		for (int n = 0; n < m_actualCols; ++n) {
 			Column* column = spreadsheet->column(n);
 
 			//determine the plots where the column is consumed
-			for (const auto* curve: curves) {
+			for (const auto* curve : curves) {
 				if (curve->xColumn() == column || curve->yColumn() == column) {
 					CartesianPlot* plot = dynamic_cast<CartesianPlot*>(curve->parentAspect());
 					if (plots.indexOf(plot) == -1) {
 						plots << plot;
 						plot->setSuppressDataChangedSignal(true);
 					}
 				}
 			}
 
 			column->setChanged();
 		}
 
 		//loop over all affected plots and retransform them
-		for (auto* const plot: plots) {
+		for (auto* const plot : plots) {
 			//TODO setting this back to true triggers again a lot of retransforms in the plot (one for each curve).
 			// 				plot->setSuppressDataChangedSignal(false);
 			plot->dataChanged();
 		}
 	}
 
 	//Set prepared true if needed
 	if(!m_prepared)
 		m_prepared = true;
 }
 
 /*!
  * \brief Prepares the filter to read from messages received by the MQTTTopic.
  * Returns whether the preparation was successful or not
  * \param message
  * \param topic
  */
 int AsciiFilterPrivate::prepareMQTTTopicToRead(const QString& message,  const QString& topic) {
 	Q_UNUSED(topic)
 	vectorNames.append("value");
 	if (endColumn == -1)
 		endColumn = 1;
 	else endColumn++;
 
 	vectorNames.prepend("timestamp");
 	endColumn++;
 
 	if (createIndexEnabled) {
 		vectorNames.prepend("index");
 		endColumn++;
 	}
 
 	m_actualCols = endColumn - startColumn + 1;
 	qDebug()<<"actual cols: "<<m_actualCols;
 
 	QStringList lineList = message.split(QRegExp("\n|\r\n|\r"), QString::SkipEmptyParts);
 	QString firstLine = lineList.takeFirst();
 	firstLine.remove(QRegExp("[\\n\\r]"));	// remove any newline
 	if (simplifyWhitespacesEnabled)
 		firstLine = firstLine.simplified();
 	DEBUG("First line: \'" << firstLine.toStdString() << '\'');
 
 	// determine separator and split first line
 	QStringList firstLineStringList;
 	if (separatingCharacter == "auto") {
 		DEBUG("automatic separator");
 		QRegExp regExp("(\\s+)|(,\\s+)|(;\\s+)|(:\\s+)");
 		firstLineStringList = firstLine.split(regExp, (QString::SplitBehavior)skipEmptyParts);
 
 		if (!firstLineStringList.isEmpty()) {
 			int length1 = firstLineStringList.at(0).length();
 			if (firstLineStringList.size() > 1) {
 				int pos2 = firstLine.indexOf(firstLineStringList.at(1), length1);
 				m_separator = firstLine.mid(length1, pos2 - length1);
 			} else {
 				//old: separator = line.right(line.length() - length1);
 				m_separator = ' ';
 			}
 		}
 	} else {	// use given separator
 		// replace symbolic "TAB" with '\t'
 		m_separator = separatingCharacter.replace(QLatin1String("2xTAB"), "\t\t", Qt::CaseInsensitive);
 		m_separator = separatingCharacter.replace(QLatin1String("TAB"), "\t", Qt::CaseInsensitive);
 		// replace symbolic "SPACE" with ' '
 		m_separator = m_separator.replace(QLatin1String("2xSPACE"), QLatin1String("  "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("3xSPACE"), QLatin1String("   "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("4xSPACE"), QLatin1String("    "), Qt::CaseInsensitive);
 		m_separator = m_separator.replace(QLatin1String("SPACE"), QLatin1String(" "), Qt::CaseInsensitive);
 		firstLineStringList = firstLine.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
 	}
 	DEBUG("separator: \'" << m_separator.toStdString() << '\'');
 	DEBUG("number of columns: " << firstLineStringList.size());
 	QDEBUG("first line: " << firstLineStringList);
 	DEBUG("headerEnabled = " << headerEnabled);
 	// parse first data line to determine data type for each column
 	columnModes.resize(m_actualCols);
 	int col = 0;
 	if (createIndexEnabled) {
 		columnModes[0] = AbstractColumn::Integer;
 		col = 1;
 	}
 
 	//set column mode for timestamp
 	columnModes[col] = AbstractColumn::DateTime;
 	col++;
 
 	auto firstValue = firstLineStringList.takeFirst();//use first value to identify column mode	
 	while(firstValue.isEmpty() || firstValue.startsWith(commentCharacter) )//get the first usable value
 		firstValue = firstLineStringList.takeFirst();
 
 	if (simplifyWhitespacesEnabled)
 		firstValue = firstValue.simplified();
 
 	columnModes[m_actualCols-1] = AbstractFileFilter::columnMode(firstValue, dateTimeFormat, numberFormat);
 
 	//Improve the column mode based on the other values from the first line
 	for (auto& valueString : firstLineStringList) {
 		if(!valueString.isEmpty() && !valueString.startsWith(commentCharacter) ){
 			if (createIndexEnabled)
 				col = 1;
 			else
 				col = 0;
 
 			if (simplifyWhitespacesEnabled)
 				valueString = valueString.simplified();
 			AbstractColumn::ColumnMode mode = AbstractFileFilter::columnMode(valueString, dateTimeFormat, numberFormat);
 
 			// numeric: integer -> numeric
 			if (mode == AbstractColumn::Numeric && columnModes[m_actualCols-1] == AbstractColumn::Integer) {
 				columnModes[m_actualCols-1] = mode;
 			}
 			// text: non text -> text
 			if (mode == AbstractColumn::Text && columnModes[m_actualCols-1] != AbstractColumn::Text) {
 				columnModes[m_actualCols-1] = mode;
 			}
 		}
 	}
 	//Improve the column mode based on the remaining values
-	for (auto& valueString: lineList) {
+	for (auto& valueString : lineList) {
 		QStringList splitString = valueString.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
-		for (auto& valueString2: splitString) {
+		for (auto& valueString2 : splitString) {
 			if (!valueString2.isEmpty() && !valueString2.startsWith(commentCharacter)) {
 
 				if (simplifyWhitespacesEnabled)
 					valueString2 = valueString2.simplified();
 				AbstractColumn::ColumnMode mode = AbstractFileFilter::columnMode(valueString2, dateTimeFormat, numberFormat);
 
 				// numeric: integer -> numeric
 				if (mode == AbstractColumn::Numeric && columnModes[m_actualCols-1] == AbstractColumn::Integer) {
 					columnModes[m_actualCols-1] = mode;
 				}
 				// text: non text -> text
 				if (mode == AbstractColumn::Text && columnModes[m_actualCols-1] != AbstractColumn::Text) {
 					columnModes[m_actualCols-1] = mode;
 				}
 			}
 		}
 	}
 
 	//determine rowcount
 	int tempRowCount = 0;
 	QStringList newDataList = message.split(QRegExp("\n|\r\n|\r"), QString::SkipEmptyParts);
-	for (auto& valueString: newDataList) {
+	for (auto& valueString : newDataList) {
 		if(!valueString.startsWith(commentCharacter)) {
 			QStringList splitString = valueString.split(m_separator, (QString::SplitBehavior)skipEmptyParts);
-			for (auto& valueString2: splitString) {
+			for (auto& valueString2 : splitString) {
 				if (!valueString2.isEmpty() && !valueString2.startsWith(commentCharacter)) {
 					tempRowCount ++;
 				}
 			}
 		}
 	}
 
 	QDEBUG("column modes = " << columnModes);
 	m_actualRows = tempRowCount;
 
 	/////////////////////////////////////////////////////////////////
 
 	int actualEndRow = endRow;
 	DEBUG("endRow = " << endRow);
 	if (endRow == -1 || endRow > m_actualRows)
 		actualEndRow = m_actualRows;
 
 	if (m_actualRows > actualEndRow)
 		m_actualRows = actualEndRow;
 
 
 	DEBUG("start/end column: " << startColumn << ' ' << endColumn);
 	DEBUG("start/end row: " << m_actualStartRow << ' ' << actualEndRow);
 	DEBUG("actual cols/rows (w/o header incl. start rows): " << m_actualCols << ' ' << m_actualRows);
 
 	return 0;
 }
 
 /*!
  * \brief After the MQTTTopic was loaded, the filter is prepared for reading
  * \param prepared
  * \param topic
  * \param separator
  */
 void AsciiFilterPrivate::setPreparedForMQTT(bool prepared, MQTTTopic *topic, const QString& separator) {
 	m_prepared = prepared;
 	//If originally it was prepared we have to restore the settings
 	if(prepared == true) {
 		m_separator = separator;
 		m_actualCols = endColumn - startColumn + 1;
 		m_actualRows = topic->rowCount();
 		//set the column modes
 		columnModes.resize(topic->columnCount());
 		for(int i = 0; i < topic->columnCount(); ++i) {
 			columnModes[i] = topic->column(i)->columnMode();
 		}
 		//set the data containers
 		m_dataContainer.resize(m_actualCols);
 		for (int n = 0; n < m_actualCols; ++n) {
 			// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 			topic->child<Column>(n)->setColumnMode(columnModes[n]);
 			switch (columnModes[n]) {
 			case AbstractColumn::Numeric: {
 				QVector<double>* vector = static_cast<QVector<double>* >(topic->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Integer: {
 				QVector<int>* vector = static_cast<QVector<int>* >(topic->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::Text: {
 				QVector<QString>* vector = static_cast<QVector<QString>*>(topic->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 			case AbstractColumn::DateTime: {
 				QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(topic->child<Column>(n)->data());
 				vector->reserve(m_actualRows);
 				vector->resize(m_actualRows);
 				m_dataContainer[n] = static_cast<void *>(vector);
 				break;
 			}
 				//TODO
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 		}
 	}
 }
 #endif
 
 /*!
  * \brief Returns the separator used by the filter
  * \return
  */
 QString AsciiFilterPrivate::separator() const {
 	return m_separator;
 }
diff --git a/src/backend/datasources/filters/FITSFilter.cpp b/src/backend/datasources/filters/FITSFilter.cpp
index 8c20aed6e..bac094178 100644
--- a/src/backend/datasources/filters/FITSFilter.cpp
+++ b/src/backend/datasources/filters/FITSFilter.cpp
@@ -1,1636 +1,1636 @@
 /***************************************************************************
 File                 : FITSFilter.cpp
 Project              : LabPlot
 Description          : FITS I/O-filter
 --------------------------------------------------------------------
 Copyright            : (C) 2016 by Fabian Kristof (fkristofszabolcs@gmail.com)
 Copyright            : (C) 2017 Alexander Semke (alexander.semke@web.de)
 ***************************************************************************/
 
 /***************************************************************************
 *                                                                         *
 *  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 "FITSFilter.h"
 #include "FITSFilterPrivate.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/column/ColumnStringIO.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/matrix/MatrixModel.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/datasources/AbstractDataSource.h"
 #include "backend/matrix/Matrix.h"
 #include "commonfrontend/matrix/MatrixView.h"
 
 #include <QMultiMap>
 #include <QFile>
 #include <QDebug>
 
 /*! \class FITSFilter
  * \brief Manages the import/export of data from/to a FITS file.
  * \since 2.2.0
  * \ingroup datasources
  */
 FITSFilter::FITSFilter():AbstractFileFilter(), d(new FITSFilterPrivate(this)) {}
 
 FITSFilter::~FITSFilter() = default;
 
 void FITSFilter::readDataFromFile(const QString &fileName, AbstractDataSource *dataSource, AbstractFileFilter::ImportMode importMode) {
 	d->readCHDU(fileName, dataSource, importMode);
 }
 
 QVector<QStringList> FITSFilter::readChdu(const QString &fileName, bool* okToMatrix, int lines) {
 	return d->readCHDU(fileName, nullptr, AbstractFileFilter::Replace, okToMatrix, lines);
 }
 
 void FITSFilter::write(const QString &fileName, AbstractDataSource *dataSource) {
 	d->writeCHDU(fileName, dataSource);
 }
 
 void FITSFilter::addNewKeyword(const QString &filename, const QList<Keyword> &keywords) {
 	d->addNewKeyword(filename, keywords);
 }
 
 void FITSFilter::updateKeywords(const QString &fileName, const QList<Keyword>& originals, const QVector<Keyword>& updates) {
 	d->updateKeywords(fileName, originals, updates);
 }
 
 void FITSFilter::deleteKeyword(const QString &fileName, const QList<Keyword>& keywords) {
 	d->deleteKeyword(fileName, keywords);
 }
 
 void FITSFilter::addKeywordUnit(const QString &fileName, const QList<Keyword> &keywords) {
 	d->addKeywordUnit(fileName, keywords);
 }
 
 void FITSFilter::removeExtensions(const QStringList &extensions) {
 	d->removeExtensions(extensions);
 }
 
 void FITSFilter::parseHeader(const QString &fileName, QTableWidget *headerEditTable, bool readKeys, const QList<Keyword> &keys) {
 	d->parseHeader(fileName, headerEditTable, readKeys, keys);
 }
 
 void FITSFilter::parseExtensions(const QString &fileName, QTreeWidget *tw, bool checkPrimary) {
 	d->parseExtensions(fileName, tw, checkPrimary);
 }
 
 QList<FITSFilter::Keyword> FITSFilter::chduKeywords(const QString &fileName) {
 	return d->chduKeywords(fileName);
 }
 
 void FITSFilter::loadFilterSettings(const QString& fileName) {
 	Q_UNUSED(fileName)
 }
 
 void FITSFilter::saveFilterSettings(const QString& fileName) const {
 	Q_UNUSED(fileName)
 }
 
 /*!
  * \brief contains the {StandardKeywords \ MandatoryKeywords} keywords
  * \return A list of keywords
  */
 QStringList FITSFilter::standardKeywords() {
 	return QStringList() << QLatin1String("(blank)") << QLatin1String("CROTA")   << QLatin1String("EQUINOX")  << QLatin1String("NAXIS")   << QLatin1String("TBCOL") << QLatin1String("TUNIT")
 	       << QLatin1String("AUTHOR")  << QLatin1String("CRPIX")   << QLatin1String("EXTEND")   << QLatin1String("OBJECT")   << QLatin1String("TDIM")  << QLatin1String("TZERO")
 	       << QLatin1String("BITPIX")  << QLatin1String("CRVAL")   << QLatin1String("EXTLEVEL") << QLatin1String("OBSERVER") << QLatin1String("TDISP") << QLatin1String("XTENSION")
 	       << QLatin1String("BLANK")   << QLatin1String("CTYPE")   << QLatin1String("EXTNAME")  << QLatin1String("ORIGIN")   << QLatin1String("TELESCOP")
 	       << QLatin1String("BLOCKED") << QLatin1String("DATAMAX")  << QLatin1String("EXTVER")
 	       << QLatin1String("BSCALE")  << QLatin1String("DATAMIN")  << QLatin1String("PSCAL")  << QLatin1String("TFORM")
 	       << QLatin1String("BUNIT")   << QLatin1String("DATE")     << QLatin1String("GROUPS")   << QLatin1String("PTYPE")   << QLatin1String("THEAP")
 	       << QLatin1String("BZERO")   << QLatin1String("DATE-OBS") << QLatin1String("HISTORY")  << QLatin1String("PZERO")   << QLatin1String("TNULL")
 	       << QLatin1String("CDELT")  << QLatin1String("INSTRUME") << QLatin1String("REFERENC") << QLatin1String("TSCAL")
 	       << QLatin1String("COMMENT") << QLatin1String("EPOCH")    << QLatin1String("NAXIS")    << QLatin1String("SIMPLE")   << QLatin1String("TTYPE");
 }
 
 /*!
  * \brief Returns a list of keywords, that are mandatory for an image extension of a FITS file
  * see:
  * https://archive.stsci.edu/fits/fits_standard/node64.html
  * \return A list of keywords
  */
 
 QStringList FITSFilter::mandatoryImageExtensionKeywords() {
 	return QStringList() << QLatin1String("XTENSION") << QLatin1String("BITPIX")
 	       << QLatin1String("NAXIS") << QLatin1String("PCOUNT")
 	       << QLatin1String("GCOUNT") << QLatin1String("END");
 }
 
 /*!
  * \brief Returns a list of keywords, that are mandatory for a table extension (ascii or bintable)
  * of a FITS file
  * see:
  * https://archive.stsci.edu/fits/fits_standard/node58.html
  * https://archive.stsci.edu/fits/fits_standard/node68.html
  * \return A list of keywords
  */
 QStringList FITSFilter::mandatoryTableExtensionKeywords() {
 	return QStringList() << QLatin1String("XTENSION") << QLatin1String("BITPIX")
 	       << QLatin1String("NAXIS") << QLatin1String("NAXIS1")
 	       << QLatin1String("NAXIS2") << QLatin1String("PCOUNT")
 	       << QLatin1String("GCOUNT") << QLatin1String("TFIELDS")
 	       << QLatin1String("END");
 }
 
 /*!
  * \brief Returns a list of strings that represent units which are used for autocompletion when adding
  * keyword units to keywords
  * \return A list of strings that represent units
  */
 QStringList FITSFilter::units() {
 	return QStringList() << QLatin1String("m (Metre)") << QLatin1String("kg (Kilogram)") << QLatin1String("s (Second)")
 	       << QString("M☉ (Solar mass)") << QLatin1String("AU (Astronomical unit") << QLatin1String("l.y (Light year)")
 	       << QLatin1String("km (Kilometres") << QLatin1String("pc (Parsec)") << QLatin1String("K (Kelvin)")
 	       << QLatin1String("mol (Mole)") << QLatin1String("cd (Candela)");
 }
 
 /*!
  * \brief Sets the startColumn to \a column
  * \param column the column to be set
  */
 void FITSFilter::setStartColumn(const int column) {
 	d->startColumn = column;
 }
 
 /*!
  * \brief Returns startColumn
  * \return The startColumn
  */
 int FITSFilter::startColumn() const {
 	return d->startColumn;
 }
 
 /*!
  * \brief Sets the endColumn to \a column
  * \param column the column to be set
  */
 void FITSFilter::setEndColumn(const int column) {
 	d->endColumn = column;
 }
 
 /*!
  * \brief Returns endColumn
  * \return The endColumn
  */
 int FITSFilter::endColumn() const {
 	return d->endColumn;
 }
 
 /*!
  * \brief Sets the startRow to \a row
  * \param row the row to be set
  */
 void FITSFilter::setStartRow(const int row) {
 	d->startRow = row;
 }
 
 /*!
  * \brief Returns startRow
  * \return The startRow
  */
 int FITSFilter::startRow() const {
 	return d->startRow;
 }
 
 /*!
  * \brief Sets the endRow to \a row
  * \param row the row to be set
  */
 void FITSFilter::setEndRow(const int row) {
 	d->endRow = row;
 }
 
 /*!
  * \brief Returns endRow
  * \return The endRow
  */
 int FITSFilter::endRow() const {
 	return d->endRow;
 }
 
 /*!
  * \brief Sets commentsAsUnits to \a commentsAsUnits
  *
  * This is used when spreadsheets are exported to FITS table extensions and comments are used as the
  * units of the table's columns.
  * \param commentsAsUnits
  */
 void FITSFilter::setCommentsAsUnits(const bool commentsAsUnits) {
 	d->commentsAsUnits = commentsAsUnits;
 }
 
 /*!
  * \brief Sets exportTo to \a exportTo
  *
  * This is used to decide whether the container should be exported to a FITS image or a FITS table
  * For an image \a exportTo should be 0, for a table 1
  * \param exportTo
  */
 void FITSFilter::setExportTo(const int exportTo) {
 	d->exportTo = exportTo;
 }
 
 QString FITSFilter::fileInfoString(const QString& fileName) {
 	const int imagesCount = FITSFilterPrivate::extensionNames(fileName).values(QLatin1String("IMAGES")).size();
 	QString info(i18n("Images: %1", QString::number(imagesCount )));
 
 	info += QLatin1String("<br>");
 
 	const int tablesCount = FITSFilterPrivate::extensionNames(fileName).values(QLatin1String("TABLES")).size();
 	info += i18n("Tables: %1", QString::number(tablesCount));
 
 	return info;
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 
 FITSFilterPrivate::FITSFilterPrivate(FITSFilter* owner) :
 	q(owner),
 	startRow(-1),
 	endRow(-1),
 	startColumn(-1),
 	endColumn(-1),
 	commentsAsUnits(false),
 	exportTo(0) {
 #ifdef HAVE_FITS
 	m_fitsFile = nullptr;
 #endif
 }
 
 /*!
  * \brief Read the current header data unit from file \a filename in data source \a dataSource in
     \a importMode import mode
  * \param fileName the name of the file to be read
  * \param dataSource the data source to be filled
  * \param importMode
  */
 QVector<QStringList> FITSFilterPrivate::readCHDU(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, bool* okToMatrix, int lines) {
 	DEBUG("FITSFilterPrivate::readCHDU() file name = " << fileName.toStdString());
 	QVector<QStringList> dataStrings;
 
 #ifdef HAVE_FITS
 	int status = 0;
 
 	if(fits_open_file(&m_fitsFile, fileName.toLatin1(), READONLY, &status)) {
 		DEBUG("	ERROR opening file " << fileName.toStdString());
 		printError(status);
 		return dataStrings;
 	}
 
 	int chduType;
 
 	if (fits_get_hdu_type(m_fitsFile, &chduType, &status)) {
 		printError(status);
 		return dataStrings;
 	}
 
 	long actualRows;
 	int actualCols;
 	int columnOffset = 0;
 
 	bool noDataSource = (dataSource == nullptr);
 
 	if(chduType == IMAGE_HDU) {
 		DEBUG("IMAGE_HDU");
 		int maxdim = 2;
 		int bitpix;
 		int naxis;
 		long naxes[2];
 
 		if (fits_get_img_param(m_fitsFile, maxdim, &bitpix, &naxis, naxes, &status)) {
 			printError(status);
 			return dataStrings;
 		}
 
 		if (naxis == 0)
 			return dataStrings;
 		actualRows = naxes[1];
 		actualCols = naxes[0];
 		if (lines == -1)
 			lines = actualRows;
 		else {
 			if (lines > actualRows)
 				lines = actualRows;
 		}
 
 		if (endRow != -1) {
 			if (!noDataSource)
 				lines = endRow;
 		}
 		if (endColumn != -1)
 			actualCols = endColumn;
 		if (noDataSource)
 			dataStrings.reserve(lines);
 
 		int i = 0;
 		int j = 0;
 		if (startRow != 1)
 			i = startRow;
 		if (startColumn != 1)
 			j = startColumn;
 
 		const int jstart = j;
 
 		//TODO: support other modes
 		QVector<AbstractColumn::ColumnMode> columnModes;
 		columnModes.resize(actualCols - j);
 		QStringList vectorNames;
 
 		QVector<void*> dataContainer;
 		if (!noDataSource) {
 			dataContainer.reserve(actualCols - j);
 			columnOffset = dataSource->prepareImport(dataContainer, importMode, lines - i, actualCols - j, vectorNames, columnModes);
 		}
 
 		long pixelCount = lines * actualCols;
 		double* data = new double[pixelCount];
 
 		if (!data) {
 			qDebug() << "Not enough memory for data";
 			return dataStrings;
 		}
 
 		if (fits_read_img(m_fitsFile, TDOUBLE, 1, pixelCount, nullptr, data, nullptr, &status)) {
 			printError(status);
 			return dataStrings << (QStringList() << QString("Error"));
 		}
 
 		int ii = 0;
 		DEBUG("	Import " << lines << " lines");
 		for (; i < lines; ++i) {
 			int jj = 0;
 			QStringList line;
 			line.reserve(actualCols - j);
 			for (; j < actualCols; ++j) {
 				if (noDataSource)
 					line << QString::number(data[i*naxes[0] +j]);
 				else
 					static_cast<QVector<double>*>(dataContainer[jj++])->operator[](ii) = data[i* naxes[0] + j];
 			}
 			dataStrings << line;
 			j = jstart;
 			ii++;
 		}
 		delete[] data;
 
 		if (dataSource)
 			dataSource->finalizeImport(columnOffset, 1, actualCols, lines, "", importMode);
 
 		fits_close_file(m_fitsFile, &status);
 
 		return dataStrings;
 
 	} else if ((chduType == ASCII_TBL) || (chduType == BINARY_TBL)) {
 		DEBUG("ASCII_TBL or BINARY_TBL");
 
 		if (endColumn != -1)
 			actualCols = endColumn;
 		else
 			fits_get_num_cols(m_fitsFile, &actualCols, &status);
 
 		if (endRow != -1)
 			actualRows = endRow;
 		else
 			fits_get_num_rows(m_fitsFile, &actualRows, &status);
 
 		QStringList columnNames;
 		QList<int> columnsWidth;
 		QStringList columnUnits;
 		columnUnits.reserve(actualCols);
 		columnsWidth.reserve(actualCols);
 		columnNames.reserve(actualCols);
 		int colWidth;
 		char keyword[FLEN_KEYWORD];
 		char value[FLEN_VALUE];
 		int col = 1;
 		if (startColumn != 1) {
 			if (startColumn != 0)
 				col = startColumn;
 		}
 		for (; col <=actualCols; ++col) {
 			status = 0;
 			fits_make_keyn("TTYPE", col, keyword, &status);
 			fits_read_key(m_fitsFile, TSTRING, keyword, value, nullptr, &status);
 			columnNames.append(QLatin1String(value));
 
 			fits_make_keyn("TUNIT", col, keyword, &status);
 			fits_read_key(m_fitsFile, TSTRING, keyword, value, nullptr, &status);
 			columnUnits.append(QLatin1String(value));
 
 			fits_get_col_display_width(m_fitsFile, col, &colWidth, &status);
 			columnsWidth.append(colWidth);
 		}
 
 		status = 0;
 		if (lines == -1)
 			lines = actualRows;
 		else if (lines > actualRows)
 			lines = actualRows;
 
 		if (endRow != -1)
 			lines = endRow;
 		QVector<QStringList*> stringDataPointers;
 		QVector<void*> numericDataPointers;
 		QList<bool> columnNumericTypes;
 
 		int startCol = 0;
 		if (startColumn != 1)
 			startCol = startColumn;
 		int startRrow = 0;
 		if (startRow != 1)
 			startRrow = startRow;
 
 		columnNumericTypes.reserve(actualCols);
 		int datatype;
 		int c = 1;
 		if (startColumn != 1) {
 			if (startColumn != 0)
 				c = startColumn;
 		}
 		QList<int> matrixNumericColumnIndices;
 		for (; c <= actualCols; ++c) {
 			fits_get_coltype(m_fitsFile, c, &datatype, nullptr, nullptr, &status);
 
 			switch (datatype) {
 			case TSTRING:
 				columnNumericTypes.append(false);
 				break;
 			case TSHORT:
 				columnNumericTypes.append(true);
 				break;
 			case TLONG:
 				columnNumericTypes.append(true);
 				break;
 			case TFLOAT:
 				columnNumericTypes.append(true);
 				break;
 			case TDOUBLE:
 				columnNumericTypes.append(true);
 				break;
 			case TLOGICAL:
 				columnNumericTypes.append(false);
 				break;
 			case TBIT:
 				columnNumericTypes.append(true);
 				break;
 			case TBYTE:
 				columnNumericTypes.append(true);
 				break;
 			case TCOMPLEX:
 				columnNumericTypes.append(true);
 				break;
 			default:
 				columnNumericTypes.append(false);
 				break;
 			}
 			if ((datatype != TSTRING) && (datatype != TLOGICAL))
 				matrixNumericColumnIndices.append(c);
 		}
 
 		if (noDataSource)
 			*okToMatrix = matrixNumericColumnIndices.isEmpty() ? false : true;
 		if (!noDataSource) {
 			DEBUG("HAS DataSource");
 			Spreadsheet* spreadsheet = dynamic_cast<Spreadsheet*>(dataSource);
 			if(spreadsheet) {
 				numericDataPointers.reserve(actualCols - startCol);
 
 				stringDataPointers.reserve(actualCols - startCol);
 				spreadsheet->setUndoAware(false);
 				columnOffset = spreadsheet->resize(importMode, columnNames, actualCols - startCol);
 
 				if (importMode == AbstractFileFilter::Replace) {
 					spreadsheet->clear();
 					spreadsheet->setRowCount(lines - startRrow);
 				} else {
 					if (spreadsheet->rowCount() < (lines - startRrow))
 						spreadsheet->setRowCount(lines - startRrow);
 				}
 				DEBUG("Reading columns ...");
 				for (int n = 0; n < actualCols - startCol; ++n) {
 					if (columnNumericTypes.at(n)) {
 						spreadsheet->column(columnOffset+ n)->setColumnMode(AbstractColumn::Numeric);
 						QVector<double>* datap = static_cast<QVector<double>* >(spreadsheet->column(columnOffset+n)->data());
 						numericDataPointers.push_back(datap);
 						if (importMode == AbstractFileFilter::Replace)
 							datap->clear();
 					} else {
 						spreadsheet->column(columnOffset+ n)->setColumnMode(AbstractColumn::Text);
 						QStringList* list = static_cast<QStringList* >(spreadsheet->column(columnOffset+n)->data());
 						stringDataPointers.push_back(list);
 						if (importMode == AbstractFileFilter::Replace)
 							list->clear();
 					}
 				}
 				DEBUG("	... DONE");
 				stringDataPointers.squeeze();
 			} else {
 				numericDataPointers.reserve(matrixNumericColumnIndices.size());
 
 				columnOffset = dataSource->prepareImport(numericDataPointers, importMode, lines - startRrow, matrixNumericColumnIndices.size());
 			}
 			numericDataPointers.squeeze();
 		}
 
 		char* array = new char[1000];	//TODO: why 1000?
 		int row = 1;
 		if (startRow != 1) {
 			if (startRow != 0)
 				row = startRow;
 		}
 
 		int coll = 1;
 		if (startColumn != 1) {
 			if (startColumn != 0)
 				coll = startColumn;
 		}
 		bool isMatrix = false;
 		if (dynamic_cast<Matrix*>(dataSource)) {
 			isMatrix = true;
 			coll = matrixNumericColumnIndices.first();
 			actualCols = matrixNumericColumnIndices.last();
 			if (importMode == AbstractFileFilter::Replace) {
-				for (auto* col: numericDataPointers)
+				for (auto* col : numericDataPointers)
 					static_cast<QVector<double>*>(col)->clear();
 			}
 		}
 
 		for (; row <= lines; ++row) {
 			int numericixd = 0;
 			int stringidx = 0;
 			QStringList line;
 			line.reserve(actualCols-coll);
 			for (int col = coll; col <= actualCols; ++col) {
 				if (isMatrix) {
 					if (!matrixNumericColumnIndices.contains(col))
 						continue;
 				}
 				if(fits_read_col_str(m_fitsFile, col, row, 1, 1, nullptr, &array, nullptr, &status))
 					printError(status);
 				if (!noDataSource) {
 					const QString& str = QString::fromLatin1(array);
 					if (str.isEmpty()) {
 						if (columnNumericTypes.at(col - 1))
 							static_cast<QVector<double>*>(numericDataPointers[numericixd++])->push_back(0);
 						else
 							stringDataPointers[stringidx++]->append(QLatin1String("NULL"));
 					} else {
 						if (columnNumericTypes.at(col - 1))
 							static_cast<QVector<double>*>(numericDataPointers[numericixd++])->push_back(str.toDouble());
 						else {
 							if (!stringDataPointers.isEmpty())
 								stringDataPointers[stringidx++]->operator<<(str.simplified());
 						}
 
 					}
 				} else {
 					QString tmpColstr = QString::fromLatin1(array);
 					tmpColstr = tmpColstr.simplified();
 					if (tmpColstr.isEmpty())
 						line << QLatin1String("NULL");
 					else
 						line << tmpColstr;
 				}
 			}
 			dataStrings << line;
 		}
 
 		delete[] array;
 
 		if (!noDataSource)
 			dataSource->finalizeImport(columnOffset, 1, actualCols, lines, "", importMode);
 
 		fits_close_file(m_fitsFile, &status);
 		return dataStrings;
 	} else
 		qDebug() << "Incorrect header type";
 
 	fits_close_file(m_fitsFile, &status);
 
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(dataSource)
 	Q_UNUSED(importMode)
 	Q_UNUSED(okToMatrix)
 	Q_UNUSED(lines)
 #endif
 	return dataStrings;
 }
 
 /*!
  * \brief Export from data source \a dataSource to file \a fileName
  * \param fileName the name of the file to be exported to
  * \param dataSource the datasource whose data is exported
  */
 
 void FITSFilterPrivate::writeCHDU(const QString &fileName, AbstractDataSource *dataSource) {
 #ifdef HAVE_FITS
 	if (!fileName.endsWith(QLatin1String(".fits")))
 		return;
 	int status = 0;
 	bool existed = false;
 	if (!QFile::exists(fileName)) {
 		if (fits_create_file(&m_fitsFile, fileName.toLatin1(), &status)) {
 			printError(status);
 			qDebug() << fileName;
 			return;
 		}
 	} else {
 		if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READWRITE, &status )) {
 			printError(status);
 			return;
 		} else
 			existed = true;
 	}
 
 	Matrix* const matrix = dynamic_cast<Matrix*>(dataSource);
 	if (matrix) {
 		//FITS image
 		if (exportTo == 0) {
 			long naxes[2] = { matrix->columnCount(), matrix->rowCount() };
 			if (fits_create_img(m_fitsFile, FLOAT_IMG, 2, naxes, &status)) {
 				printError(status);
 				status = 0;
 				fits_close_file(m_fitsFile, &status);
 				return;
 			}
 			const long nelem = naxes[0] * naxes[1];
 			double* const array = new double[nelem];
 			const QVector<QVector<double> >* const data = static_cast<QVector<QVector<double>>*>(matrix->data());
 
 			for (int col = 0; col < naxes[0]; ++col)
 				for (int row = 0; row < naxes[1]; ++row)
 					array[row * naxes[0] + col] = data->at(row).at(col);
 
 			if (fits_write_img(m_fitsFile, TDOUBLE, 1, nelem, array, &status )) {
 				printError(status);
 				status = 0;
 			}
 
 			fits_close_file(m_fitsFile, &status);
 			delete[] array;
 			//FITS table
 		} else {
 			const int nrows = matrix->rowCount();
 			const int tfields = matrix->columnCount();
 			QVector<char*> columnNames;
 			columnNames.resize(tfields);
 			columnNames.reserve(tfields);
 			QVector<char*> tform;
 			tform.resize(tfields);
 			tform.reserve(tfields);
 			QVector<char*> tunit;
 			tunit.resize(tfields);
 			tunit.reserve(tfields);
 			//TODO: mode
 			const QVector<QVector<double>>* const matrixData = static_cast<QVector<QVector<double>>*>(matrix->data());
 			QVector<double> column;
 			const MatrixModel* matrixModel = static_cast<MatrixView*>(matrix->view())->model();
 			const int precision = matrix->precision();
 			for (int i = 0; i < tfields; ++i) {
 				column = matrixData->at(i);
 				const QString& columnName = matrixModel->headerData(i, Qt::Horizontal).toString();
 				columnNames[i] = new char[columnName.size()];
 				strcpy(columnNames[i], columnName.toLatin1().data());
 
 				tunit[i] = new char[1];
 				strcpy(tunit[i], "");
 				int maxSize = -1;
 				for (int row = 0; row < nrows; ++row) {
 					if (matrix->text<double>(row, i).size() > maxSize)
 						maxSize = matrix->text<double>(row, i).size();
 				}
 				QString tformn;
 				if (precision > 0) {
 					tformn = QLatin1String("F")+ QString::number(maxSize) + QLatin1String(".") +
 					         QString::number(precision);
 				} else
 					tformn = QLatin1String("F")+ QString::number(maxSize) + QLatin1String(".0");
 				tform[i] = new char[tformn.size()];
 				strcpy(tform[i], tformn.toLatin1().data());
 			}
 			//TODO extension name containing[] ?
 
 			if (fits_create_tbl(m_fitsFile, ASCII_TBL,
 			                    nrows, tfields,
 								columnNames.data(), tform.data(), tunit.data(),
 			                    matrix->name().toLatin1().data(),&status )) {
 				printError(status);
 
 				qDeleteAll(tform);
 				qDeleteAll(tunit);
 				qDeleteAll(columnNames);
 				status = 0;
 				fits_close_file(m_fitsFile, &status);
 				if (!existed) {
 					QFile file(fileName);
 					file.remove();
 				}
 				return;
 			}
 			qDeleteAll(tform);
 			qDeleteAll(tunit);
 			qDeleteAll(columnNames);
 
 			double* columnNumeric = new double[nrows];
 			for (int col = 1; col <= tfields; ++col) {
 				column = matrixData->at(col-1);
 				for (int r = 0; r < column.size(); ++r)
 					columnNumeric[r] = column.at(r);
 
 				fits_write_col(m_fitsFile, TDOUBLE, col, 1, 1, nrows, columnNumeric, &status);
 				if (status) {
 					printError(status);
 					delete[] columnNumeric;
 					status = 0;
 					if (!existed) {
 						QFile file(fileName);
 						file.remove();
 					}
 
 					fits_close_file(m_fitsFile, &status);
 					return;
 				}
 			}
 			delete[] columnNumeric;
 			fits_close_file(m_fitsFile, &status);
 		}
 		return;
 	}
 
 	Spreadsheet* const spreadsheet = dynamic_cast<Spreadsheet*>(dataSource);
 	if (spreadsheet) {
 		//FITS image
 		if (exportTo == 0) {
 			int maxRowIdx = -1;
 			//don't export lots of empty lines if all of those contain nans
 			// TODO: option?
 			for (int c = 0; c < spreadsheet->columnCount(); ++c) {
 				const Column* const col = spreadsheet->column(c);
 				int currMaxRoxIdx = -1;
 				for (int r = col->rowCount(); r >= 0; --r) {
 					if (col->isValid(r)) {
 						currMaxRoxIdx = r;
 						break;
 					}
 				}
 
 				if (currMaxRoxIdx > maxRowIdx) {
 					maxRowIdx = currMaxRoxIdx;
 				}
 			}
 			long naxes[2] = { spreadsheet->columnCount(), maxRowIdx + 1};
 			if (fits_create_img(m_fitsFile, FLOAT_IMG, 2, naxes, &status)) {
 				printError(status);
 				status = 0;
 				fits_close_file(m_fitsFile, &status);
 				if (!existed) {
 					QFile file(fileName);
 					file.remove();
 				}
 				return;
 			}
 			const long nelem = naxes[0] * naxes[1];
 			double* array = new double[nelem];
 
 			for (int row = 0; row < naxes[1]; ++row) {
 				for (int col = 0; col < naxes[0]; ++col)
 					array[row * naxes[0] + col] = spreadsheet->column(col)->valueAt(row);
 			}
 
 			if (fits_write_img(m_fitsFile, TDOUBLE, 1, nelem, array, &status )) {
 				printError(status);
 				status = 0;
 				fits_close_file(m_fitsFile, &status);
 				if (!existed) {
 					QFile file(fileName);
 					file.remove();
 				}
 				return;
 			}
 
 			fits_close_file(m_fitsFile, &status);
 			delete[] array;
 		} else {
 			const int nrows = spreadsheet->rowCount();
 			const int tfields = spreadsheet->columnCount();
 
 			QVector<char*> columnNames;
 			columnNames.resize(tfields);
 			columnNames.reserve(tfields);
 			QVector<char*> tform;
 			tform.resize(tfields);
 			tform.reserve(tfields);
 			QVector<char*> tunit;
 			tunit.resize(tfields);
 			tunit.reserve(tfields);
 
 			for (int i = 0; i < tfields; ++i) {
 				const Column* const column =  spreadsheet->column(i);
 
 				columnNames[i] = new char[column->name().size()];
 				strcpy(columnNames[i], column->name().toLatin1().data());
 				if (commentsAsUnits) {
 					tunit[i] = new char[column->comment().size()];
 					strcpy(tunit[i], column->comment().toLatin1().constData());
 				} else {
 					tunit[i] = new char[2];
 					strcpy(tunit[i], "");
 				}
 				switch (column->columnMode()) {
 				case AbstractColumn::Numeric: {
 						int maxSize = -1;
 						for (int row = 0; row < nrows; ++row) {
 							if (QString::number(column->valueAt(row)).size() > maxSize)
 								maxSize = QString::number(column->valueAt(row)).size();
 						}
 
 						const Double2StringFilter* const filter = static_cast<Double2StringFilter*>(column->outputFilter());
 						bool decimals = false;
 						for (int ii = 0; ii < nrows; ++ii) {
 							bool ok;
 							QString cell = column->asStringColumn()->textAt(ii);
 							double val = cell.toDouble(&ok);
 							if (cell.size() > QString::number(val).size() + 1) {
 								decimals = true;
 								break;
 							}
 						}
 						QString tformn;
 						if (decimals) {
 							int maxStringSize = -1;
 							for (int row = 0; row < nrows; ++row) {
 								if (column->asStringColumn()->textAt(row).size() > maxStringSize)
 									maxStringSize = column->asStringColumn()->textAt(row).size();
 							}
 							const int diff = abs(maxSize - maxStringSize);
 							maxSize+= diff;
 							tformn = QLatin1String("F")+ QString::number(maxSize) + QLatin1String(".") +
 							         QString::number(filter->numDigits());
 						} else
 							tformn = QLatin1String("F")+ QString::number(maxSize) + QLatin1String(".0");
 						tform[i] = new char[tformn.size()];
 						strcpy(tform[i], tformn.toLatin1().data());
 						break;
 					}
 				case AbstractColumn::Text: {
 						int maxSize = -1;
 						for (int row = 0; row < nrows; ++row) {
 							if (column->textAt(row).size() > maxSize)
 								maxSize = column->textAt(row).size();
 						}
 						const QString& tformn = QLatin1String("A") + QString::number(maxSize);
 						tform[i] = new char[tformn.size()];
 						strcpy(tform[i], tformn.toLatin1().data());
 						break;
 					}
 				case AbstractColumn::Integer:	//TODO
 				case AbstractColumn::DateTime:
 				case AbstractColumn::Day:
 				case AbstractColumn::Month:
 					break;
 				}
 			}
 			//TODO extension name containing[] ?
 
 			if (fits_create_tbl(m_fitsFile, ASCII_TBL,
 			                    nrows, tfields,
 								columnNames.data(), tform.data(), tunit.data(),
 			                    spreadsheet->name().toLatin1().data(),&status )) {
 				printError(status);
 				qDeleteAll(tform);
 				qDeleteAll(tunit);
 				qDeleteAll(columnNames);
 				status = 0;
 				fits_close_file(m_fitsFile, &status);
 				if (!existed) {
 					QFile file(fileName);
 					file.remove();
 				}
 				return;
 			}
 
 			qDeleteAll(tform);
 			qDeleteAll(tunit);
 			qDeleteAll(columnNames);
 
 			QVector<char*> column;
 			column.resize(nrows);
 			column.reserve(nrows);
 
 			double* columnNumeric = new double[nrows];
 			bool hadTextColumn = false;
 			for (int col = 1; col <= tfields; ++col) {
 				const Column* c =  spreadsheet->column(col-1);
 				AbstractColumn::ColumnMode columnMode = c->columnMode();
 
 				if (columnMode == AbstractColumn::Numeric) {
 					for (int row = 0; row < nrows; ++row)
 						columnNumeric[row] = c->valueAt(row);
 
 					fits_write_col(m_fitsFile, TDOUBLE, col, 1, 1, nrows, columnNumeric, &status);
 					if (status) {
 						printError(status);
 						delete[] columnNumeric;
 						status = 0;
 						fits_close_file(m_fitsFile, &status);
 						if (!existed) {
 							QFile file(fileName);
 							file.remove();
 						}
 						return;
 					}
 				} else {
 					hadTextColumn = true;
 					for (int row = 0; row < nrows; ++row) {
 						column[row] = new char[c->textAt(row).size()];
 
 						strcpy(column[row], c->textAt(row).toLatin1().data());
 					}
 					fits_write_col(m_fitsFile, TSTRING, col, 1, 1, nrows, column.data(), &status);
 					if (status) {
 						printError(status);
 						qDeleteAll(column);
 						status = 0;
 						fits_close_file(m_fitsFile, &status);
 						return;
 					}
 				}
 			}
 
 			delete[] columnNumeric;
 			if (hadTextColumn)
 				qDeleteAll(column);
 
 			status = 0;
 			fits_close_file(m_fitsFile, &status);
 		}
 	}
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(dataSource)
 #endif
 }
 
 /*!
  * \brief Return a map of the available extensions names in file \a filename
  *        The keys of the map are the extension types, the values are the names
  * \param fileName the name of the FITS file to be analyzed
  */
 QMultiMap<QString, QString> FITSFilterPrivate::extensionNames(const QString& fileName) {
 	DEBUG("FITSFilterPrivate::extensionNames() file name = " << fileName.toStdString());
 #ifdef HAVE_FITS
 	QMultiMap<QString, QString> extensions;
 	int status = 0;
 	fitsfile* fitsFile = nullptr;
 	if (fits_open_file(&fitsFile, fileName.toLatin1(), READONLY, &status ))
 		return QMultiMap<QString, QString>();
 	int hduCount;
 
 	if (fits_get_num_hdus(fitsFile, &hduCount, &status))
 		return QMultiMap<QString, QString>();
 	int imageCount = 0;
 	int asciiTableCount = 0;
 	int binaryTableCount = 0;
 	for (int currentHDU = 1; (currentHDU <= hduCount) && !status; ++currentHDU) {
 		int hduType;
 		status = 0;
 
 		fits_get_hdu_type(fitsFile, &hduType, &status);
 		switch (hduType) {
 		case IMAGE_HDU:
 			imageCount++;
 			break;
 		case ASCII_TBL:
 			asciiTableCount++;
 			break;
 		case BINARY_TBL:
 			binaryTableCount++;
 			break;
 		}
 		char* keyVal = new char[FLEN_VALUE];
 		QString extName;
 		if (!fits_read_keyword(fitsFile,"EXTNAME", keyVal, nullptr, &status)) {
 			extName = QLatin1String(keyVal);
 			extName = extName.mid(1, extName.length() -2).simplified();
 		} else {
 			status = 0;
 			if (!fits_read_keyword(fitsFile,"HDUNAME", keyVal, nullptr, &status)) {
 				extName = QLatin1String(keyVal);
 				extName = extName.mid(1, extName.length() -2).simplified();
 			} else {
 				status = 0;
 				switch (hduType) {
 				case IMAGE_HDU:
 					if (imageCount == 1)
 						extName = i18n("Primary header");
 					else
 						extName = i18n("IMAGE #%1", imageCount);
 					break;
 				case ASCII_TBL:
 					extName = i18n("ASCII_TBL #%1", asciiTableCount);
 					break;
 				case BINARY_TBL:
 					extName = i18n("BINARY_TBL #%1", binaryTableCount);
 					break;
 				}
 			}
 		}
 		delete[] keyVal;
 		status = 0;
 		extName = extName.trimmed();
 		switch (hduType) {
 		case IMAGE_HDU:
 			extensions.insert(QLatin1String("IMAGES"), extName);
 			break;
 		case ASCII_TBL:
 			extensions.insert(QLatin1String("TABLES"), extName);
 			break;
 		case BINARY_TBL:
 			extensions.insert(QLatin1String("TABLES"), extName);
 			break;
 		}
 		fits_movrel_hdu(fitsFile, 1, nullptr, &status);
 	}
 
 	if (status == END_OF_FILE)
 		status = 0;
 
 	fits_close_file(fitsFile, &status);
 	return extensions;
 #else
 	Q_UNUSED(fileName)
 	return QMultiMap<QString, QString>();
 #endif
 }
 
 /*!
  * \brief Prints the error text corresponding to the status code \a status
  * \param status the status code of the error
  */
 void FITSFilterPrivate::printError(int status) const {
 #ifdef HAVE_FITS
 	if (status) {
 		char errorText[FLEN_ERRMSG];
 		fits_get_errstatus(status, errorText );
 		qDebug() << QLatin1String(errorText);
 	}
 #else
 	Q_UNUSED(status)
 #endif
 }
 
 /*!
  * \brief Add the keywords \a keywords to the current header unit
  * \param keywords the keywords to be added
  * \param fileName the name of the FITS file (extension) in which the keywords are added
  */
 
 void FITSFilterPrivate::addNewKeyword(const QString& fileName, const QList<FITSFilter::Keyword>& keywords) {
 #ifdef HAVE_FITS
 	int status = 0;
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READWRITE, &status )) {
 		printError(status);
 		return;
 	}
 	for (const FITSFilter::Keyword& keyword: keywords) {
 		status = 0;
 		if (!keyword.key.compare(QLatin1String("COMMENT"))) {
 			if (fits_write_comment(m_fitsFile, keyword.value.toLatin1(), &status))
 				printError(status);
 		} else if (!keyword.key.compare(QLatin1String("HISTORY"))) {
 			if (fits_write_history(m_fitsFile, keyword.value.toLatin1(), &status))
 				printError(status);
 		} else if (!keyword.key.compare(QLatin1String("DATE"))) {
 			if (fits_write_date(m_fitsFile, &status))
 				printError(status);
 		} else {
 			int ok = 0;
 			if (keyword.key.length() <= FLEN_KEYWORD) {
 				ok++;
 				if (keyword.value.length() <= FLEN_VALUE) {
 					ok++;
 					if(keyword.comment.length() <= FLEN_COMMENT)
 						ok++;
 				}
 			}
 			if (ok == 3) {
 				bool ok;
 				double val = keyword.value.toDouble(&ok);
 				if (ok) {
 					if (fits_write_key(m_fitsFile,
 					                   TDOUBLE,
 					                   keyword.key.toLatin1().data(),
 					                   &val,
 					                   keyword.comment.toLatin1().data(),
 					                   &status))
 						printError(status);
 				} else {
 					if (fits_write_key(m_fitsFile,
 					                   TSTRING,
 					                   keyword.key.toLatin1().data(),
 					                   keyword.value.toLatin1().data(),
 					                   keyword.comment.toLatin1().data(),
 					                   &status))
 						printError(status);
 				}
 			} else if ( ok == 2) {
 				//comment too long
 			} else if ( ok == 1) {
 				//value too long
 			} else {
 				//keyword too long
 			}
 		}
 	}
 	status = 0;
 	fits_close_file(m_fitsFile, &status);
 #else
 	Q_UNUSED(keywords)
 	Q_UNUSED(fileName)
 
 #endif
 }
 /*!
  * \brief Update keywords in the current header unit
  * \param fileName The name of the FITS file (extension) in which the keywords will be updated
  * \param originals The original keywords of the FITS file (extension)
  * \param updates The keywords that contain the updated values
  */
 void FITSFilterPrivate::updateKeywords(const QString& fileName,
                                        const QList<FITSFilter::Keyword>& originals,
                                        const QVector<FITSFilter::Keyword>& updates) {
 #ifdef HAVE_FITS
 	int status = 0;
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READWRITE, &status )) {
 		printError(status);
 		return;
 	}
 	FITSFilter::Keyword updatedKeyword;
 	FITSFilter::Keyword originalKeyword;
 	FITSFilter::KeywordUpdate keywordUpdate;
 
 	for (int i = 0; i < updates.size(); ++i) {
 		updatedKeyword = updates.at(i);
 		originalKeyword = originals.at(i);
 		keywordUpdate = originals.at(i).updates;
 		if (keywordUpdate.keyUpdated &&
 		        keywordUpdate.valueUpdated &&
 		        keywordUpdate.commentUpdated) {
 			if (updatedKeyword.isEmpty()) {
 				if (fits_delete_key(m_fitsFile, originalKeyword.key.toLatin1(), &status)) {
 					printError(status);
 					status = 0;
 				}
 				continue;
 			}
 		}
 		if (!updatedKeyword.key.isEmpty()) {
 			if (fits_modify_name(m_fitsFile, originalKeyword.key.toLatin1(), updatedKeyword.key.toLatin1(), &status )) {
 				printError(status);
 				status = 0;
 			}
 		}
 
 		if (!updatedKeyword.value.isEmpty()) {
 			bool ok;
 			int intValue;
 			double doubleValue;
 			bool updated = false;
 
 			doubleValue = updatedKeyword.value.toDouble(&ok);
 			if (ok) {
 				if (fits_update_key(m_fitsFile,TDOUBLE,
 				                    keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 				                    &doubleValue,
 				                    nullptr, &status))
 					printError(status);
 				else
 					updated = true;
 			}
 			if (!updated) {
 				intValue = updatedKeyword.value.toInt(&ok);
 				if (ok) {
 					if (fits_update_key(m_fitsFile,TINT,
 					                    keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 					                    &intValue,
 					                    nullptr, &status))
 						printError(status);
 					else
 						updated = true;
 				}
 			}
 			if (!updated) {
 				if (fits_update_key(m_fitsFile,TSTRING,
 				                    keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 				                    updatedKeyword.value.toLatin1().data(),
 				                    nullptr, &status))
 					printError(status);
 			}
 		} else {
 			if (keywordUpdate.valueUpdated) {
 				if (fits_update_key_null(m_fitsFile,
 				                         keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 				                         nullptr, &status)) {
 					printError(status);
 					status = 0;
 				}
 			}
 		}
 
 		if (!updatedKeyword.comment.isEmpty()) {
 			if (fits_modify_comment(m_fitsFile, keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 			                        updatedKeyword.comment.toLatin1().data(), &status)) {
 				printError(status);
 				status = 0;
 			}
 		} else {
 			if (keywordUpdate.commentUpdated) {
 				if (fits_modify_comment(m_fitsFile,
 				                        keywordUpdate.keyUpdated ? updatedKeyword.key.toLatin1() : originalKeyword.key.toLatin1(),
 				                        QString("").toLatin1().data(), &status)) {
 					printError(status);
 					status = 0;
 				}
 			}
 		}
 	}
 	status = 0;
 	fits_close_file(m_fitsFile, &status);
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(originals)
 	Q_UNUSED(updates)
 #endif
 }
 
 /*!
  * \brief Delete the keywords \a keywords from the current header unit
  * \param fileName the name of the FITS file (extension) in which the keywords will be deleted.
  * \param keywords the keywords to deleted
  */
 
 void FITSFilterPrivate::deleteKeyword(const QString& fileName, const QList<FITSFilter::Keyword> &keywords) {
 #ifdef HAVE_FITS
 	int status = 0;
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READWRITE, &status )) {
 		printError(status);
 		return;
 	}
 	for (const auto& keyword : keywords) {
 		if (!keyword.key.isEmpty()) {
 			status = 0;
 			if (fits_delete_key(m_fitsFile, keyword.key.toLatin1(), &status))
 				printError(status);
 		}
 	}
 	status = 0;
 	fits_close_file(m_fitsFile, &status);
 #else
 	Q_UNUSED(keywords)
 	Q_UNUSED(fileName)
 #endif
 }
 
 /*!
  * \brief FITSFilterPrivate::addKeywordUnit
  * \param fileName the FITS file (extension) in which the keyword units are updated/added
  * \param keywords the keywords whose units were modified/added
  */
 
 void FITSFilterPrivate::addKeywordUnit(const QString &fileName, const QList<FITSFilter::Keyword> &keywords) {
 #ifdef HAVE_FITS
 	int status = 0;
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READWRITE, &status )) {
 		printError(status);
 		return;
 	}
 
 	for(const FITSFilter::Keyword& keyword : keywords) {
 		if (keyword.updates.unitUpdated) {
 			if (fits_write_key_unit(m_fitsFile, keyword.key.toLatin1(), keyword.unit.toLatin1().data(), &status)) {
 				printError(status);
 				status = 0;
 			}
 		}
 	}
 	status = 0;
 	fits_close_file(m_fitsFile, &status);
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(keywords)
 #endif
 }
 
 /*!
  * \brief Remove extensions from a FITS file
  * \param extensions The extensions to be removed from the FITS file
  */
 void FITSFilterPrivate::removeExtensions(const QStringList &extensions) {
 #ifdef HAVE_FITS
 	int status = 0;
 	for (const auto& ext : extensions) {
 		status = 0;
 		if (fits_open_file(&m_fitsFile, ext.toLatin1(), READWRITE, &status )) {
 			printError(status);
 			continue;
 		}
 
 		if (fits_delete_hdu(m_fitsFile, nullptr, &status))
 			printError(status);
 
 		status = 0;
 		fits_close_file(m_fitsFile, &status);
 	}
 #else
 	Q_UNUSED(extensions)
 #endif
 }
 
 /*!
  * \brief Returns a list of keywords in the current header of \a fileName
  * \param fileName the name of the FITS file (extension) to be opened
  * \return A list of keywords
  */
 QList<FITSFilter::Keyword> FITSFilterPrivate::chduKeywords(const QString& fileName) {
 #ifdef HAVE_FITS
 	int status = 0;
 
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READONLY, &status )) {
 		printError(status);
 		return QList<FITSFilter::Keyword> ();
 	}
 	int numberOfKeys;
 	if (fits_get_hdrspace(m_fitsFile, &numberOfKeys, nullptr, &status)) {
 		printError(status);
 		return QList<FITSFilter::Keyword> ();
 	}
 
 	QList<FITSFilter::Keyword> keywords;
 	keywords.reserve(numberOfKeys);
 	char* key = new char[FLEN_KEYWORD];
 	char* value = new char[FLEN_VALUE];
 	char* comment = new char[FLEN_COMMENT];
 	char* unit = new char[FLEN_VALUE];
 	for (int i = 1; i <= numberOfKeys; ++i) {
 		QStringList recordValues;
 		FITSFilter::Keyword keyword;
 
 		if (fits_read_keyn(m_fitsFile, i, key, value, comment, &status)) {
 			printError(status);
 			status = 0;
 			continue;
 		}
 
 		fits_read_key_unit(m_fitsFile, key, unit, &status);
 
 		recordValues << QLatin1String(key) << QLatin1String(value) << QLatin1String(comment) << QLatin1String(unit);
 
 		keyword.key = recordValues[0].simplified();
 		keyword.value = recordValues[1].simplified();
 		keyword.comment = recordValues[2].simplified();
 		keyword.unit = recordValues[3].simplified();
 
 		keywords.append(keyword);
 	}
 	delete[] key;
 	delete[] value;
 	delete[] comment;
 	delete[] unit;
 
 	fits_close_file(m_fitsFile, &status);
 
 	return keywords;
 #else
 	Q_UNUSED(fileName)
 	return QList<FITSFilter::Keyword>();
 #endif
 }
 
 /*!
  * \brief Builds the table \a headerEditTable from the keywords \a keys
  * \param fileName The name of the FITS file from which the keys are read if \a readKeys is \c true
  * \param headerEditTable The table to be built
  * \param readKeys It's used to determine whether the keywords are provided or they should be read from
  * file \a fileName
  * \param keys The keywords that are provided if the keywords were read already.
  */
 void FITSFilterPrivate::parseHeader(const QString &fileName, QTableWidget *headerEditTable,
                                     bool readKeys, const QList<FITSFilter::Keyword>& keys) {
 #ifdef HAVE_FITS
 	QList<FITSFilter::Keyword> keywords;
 	if (readKeys)
 		keywords = chduKeywords(fileName);
 	else
 		keywords = keys;
 
 	headerEditTable->setRowCount(keywords.size());
 	QTableWidgetItem* item;
 	for (int i = 0; i < keywords.size(); ++i) {
 		const FITSFilter::Keyword& keyword = keywords.at(i);
 		const bool mandatory = FITSFilter::mandatoryImageExtensionKeywords().contains(keyword.key) ||
 		                       FITSFilter::mandatoryTableExtensionKeywords().contains(keyword.key);
 		item = new QTableWidgetItem(keyword.key);
 		const QString& itemText = item->text();
 		const bool notEditableKey = mandatory || itemText.contains(QLatin1String("TFORM")) ||
 		                            itemText.contains(QLatin1String("TTYPE")) ||
 		                            itemText.contains(QLatin1String("TUNIT"))  ||
 		                            itemText.contains(QLatin1String("TDISP")) ||
 		                            itemText.contains(QLatin1String("TBCOL")) ||
 		                            itemText.contains(QLatin1String("TZERO"));
 		const bool notEditableValue= mandatory || itemText.contains(QLatin1String("TFORM")) ||
 		                             itemText.contains(QLatin1String("TDISP")) ||
 		                             itemText.contains(QLatin1String("TBCOL")) ||
 		                             itemText.contains(QLatin1String("TZERO"));
 
 		if (notEditableKey)
 			item->setFlags(item->flags() & ~Qt::ItemIsEditable);
 		else
 			item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 		headerEditTable->setItem(i, 0, item );
 
 		item = new QTableWidgetItem(keyword.value);
 		if (notEditableValue)
 			item->setFlags(item->flags() & ~Qt::ItemIsEditable);
 		else
 			item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 		headerEditTable->setItem(i, 1, item );
 		QString commentFieldText;
 		if (!keyword.unit.isEmpty()) {
 			if (keyword.updates.unitUpdated) {
 				const QString& comment = keyword.comment.right(
 				                             keyword.comment.size() - keyword.comment.indexOf(QChar(']'))-1);
 				commentFieldText = QLatin1String("[") + keyword.unit + QLatin1String("] ") + comment;
 			} else {
 				if (keyword.comment.at(0) == QLatin1Char('['))
 					commentFieldText = keyword.comment;
 				else
 					commentFieldText = QLatin1String("[") + keyword.unit + QLatin1String("] ") + keyword.comment;
 			}
 		} else
 			commentFieldText = keyword.comment;
 		item = new QTableWidgetItem(commentFieldText);
 
 		item->setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 		headerEditTable->setItem(i, 2, item );
 	}
 
 	headerEditTable->resizeColumnsToContents();
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(headerEditTable)
 	Q_UNUSED(readKeys)
 	Q_UNUSED(keys)
 #endif
 }
 
 /*!
  * \brief Helper function to return the value of the key \a key
  * \param fileName The name of the FITS file (extension) in which the keyword with key \a key should exist
  * \param key The key of the keyword whose value it's returned
  * \return The value of the keyword as a string
  */
 const QString FITSFilterPrivate::valueOf(const QString& fileName, const char *key) {
 #ifdef HAVE_FITS
 	int status = 0;
 	if (fits_open_file(&m_fitsFile, fileName.toLatin1(), READONLY, &status )) {
 		printError(status);
 		return QString ();
 	}
 
 	char* keyVal = new char[FLEN_VALUE];
 	QString keyValue;
 	if (!fits_read_keyword(m_fitsFile, key, keyVal, nullptr, &status)) {
 		keyValue = QLatin1String(keyVal);
 		keyValue = keyValue.simplified();
 	} else {
 		printError(status);
 		delete[] keyVal;
 		fits_close_file(m_fitsFile, &status);
 		return QString();
 	}
 
 	delete[] keyVal;
 	status = 0;
 	fits_close_file(m_fitsFile, &status);
 	return keyValue;
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(key)
 	return QString();
 #endif
 }
 
 /*!
  * \brief Build the extensions tree from FITS file (extension) \a fileName
  * \param fileName The name of the FITS file to be opened
  * \param tw The QTreeWidget to be built
  * \param checkPrimary Used to determine whether the tree will be used for import or the header edit,
  * if it's \c true and if the primary array it's empty, then the item won't be added to the tree
  */
 void FITSFilterPrivate::parseExtensions(const QString &fileName, QTreeWidget *tw, bool checkPrimary) {
 	DEBUG("FITSFilterPrivate::parseExtensions()");
 #ifdef HAVE_FITS
 	const QMultiMap<QString, QString>& extensions = extensionNames(fileName);
 	const QStringList& imageExtensions = extensions.values(QLatin1String("IMAGES"));
 	const QStringList& tableExtensions = extensions.values(QLatin1String("TABLES"));
 
 	QTreeWidgetItem* root = tw->invisibleRootItem();
 	//TODO: fileName may contain any data type: check if it's a FITS file
 	QTreeWidgetItem* treeNameItem = new QTreeWidgetItem((QTreeWidgetItem*)nullptr, QStringList() << fileName);
 	root->addChild(treeNameItem);
 	treeNameItem->setExpanded(true);
 
 	QTreeWidgetItem* imageExtensionItem = new QTreeWidgetItem((QTreeWidgetItem*)nullptr, QStringList() << i18n("Images"));
 	imageExtensionItem->setFlags(imageExtensionItem->flags() & ~Qt::ItemIsSelectable );
 	QString primaryHeaderNaxis = valueOf(fileName, "NAXIS");
 	const int naxis = primaryHeaderNaxis.toInt();
 	bool noImage = false;
 	for (const QString& ext : imageExtensions) {
 		QTreeWidgetItem* treeItem = new QTreeWidgetItem((QTreeWidgetItem*)nullptr, QStringList() << ext);
 		if (ext == i18n("Primary header")) {
 			if (checkPrimary && naxis == 0)
 				continue;
 		}
 		imageExtensionItem->addChild(treeItem);
 	}
 	if (imageExtensionItem->childCount() > 0) {
 		treeNameItem->addChild(imageExtensionItem);
 		imageExtensionItem->setIcon(0,QIcon::fromTheme("view-preview"));
 		imageExtensionItem->setExpanded(true);
 		imageExtensionItem->child(0)->setSelected(true);
 
 		tw->setCurrentItem(imageExtensionItem->child(0));
 	} else
 		noImage = true;
 
 	if (tableExtensions.size() > 0) {
 		QTreeWidgetItem* tableExtensionItem = new QTreeWidgetItem((QTreeWidgetItem*)nullptr, QStringList() << i18n("Tables"));
 		tableExtensionItem->setFlags(tableExtensionItem->flags() & ~Qt::ItemIsSelectable );
 
 		for (const QString& ext : tableExtensions) {
 			QTreeWidgetItem* treeItem = new QTreeWidgetItem((QTreeWidgetItem*)nullptr, QStringList() << ext);
 			tableExtensionItem->addChild(treeItem);
 		}
 		if (tableExtensionItem->childCount() > 0) {
 			treeNameItem->addChild(tableExtensionItem);
 			tableExtensionItem->setIcon(0,QIcon::fromTheme("x-office-spreadsheet"));
 			tableExtensionItem->setExpanded(true);
 			if (noImage) {
 				tableExtensionItem->child(0)->setSelected(true);
 				tw->setCurrentItem(tableExtensionItem->child(0));
 			}
 		}
 	}
 #else
 	Q_UNUSED(fileName)
 	Q_UNUSED(tw)
 	Q_UNUSED(checkPrimary)
 #endif
 	DEBUG("FITSFilterPrivate::parseExtensions() DONE");
 }
 
 /*!
  * \brief FITSFilterPrivate::~FITSFilterPrivate
  */
 
 FITSFilterPrivate::~FITSFilterPrivate() = default;
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 
 /*!
   Saves as XML.
 */
 
 void FITSFilter::save(QXmlStreamWriter * writer) const {
 	Q_UNUSED(writer)
 }
 
 /*!
   Loads from XML.
 */
 
 bool FITSFilter::load(XmlStreamReader * loader) {
 	Q_UNUSED(loader)
 	return false;
 }
diff --git a/src/backend/datasources/filters/JsonFilter.cpp b/src/backend/datasources/filters/JsonFilter.cpp
index 1750ab586..8b2f1873f 100644
--- a/src/backend/datasources/filters/JsonFilter.cpp
+++ b/src/backend/datasources/filters/JsonFilter.cpp
@@ -1,851 +1,851 @@
 /***************************************************************************
     File                 : JsonFilter.cpp
     Project              : LabPlot
     Description          : JSON I/O-filter.
     --------------------------------------------------------------------
     --------------------------------------------------------------------
     Copyright            : (C) 2018 Andrey Cygankov (craftplace.ms@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/filters/JsonFilter.h"
 #include "backend/datasources/filters/JsonFilterPrivate.h"
 #include "backend/datasources/AbstractDataSource.h"
 #include "backend/core/column/Column.h"
 
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QDataStream>
 #include <QDateTime>
 #include <KLocalizedString>
 #include <KFilterDev>
 
 /*!
 \class JsonFilter
 \brief Manages the import/export of data from/to a file formatted using JSON.
 
 \ingroup datasources
 */
 JsonFilter::JsonFilter() : AbstractFileFilter(), d(new JsonFilterPrivate(this)) {}
 
 JsonFilter::~JsonFilter() = default;
 
 /*!
 reads the content of the device \c device.
 */
 void JsonFilter::readDataFromDevice(QIODevice& device, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	d->readDataFromDevice(device, dataSource, importMode, lines);
 }
 
 /*!
 reads the content of the file \c fileName.
 */
 void JsonFilter::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode) {
 	d->readDataFromFile(fileName, dataSource, importMode);
 }
 
 QVector<QStringList> JsonFilter::preview(const QString& fileName) {
 	return d->preview(fileName);
 }
 
 QVector<QStringList> JsonFilter::preview(QIODevice& device) {
 	return d->preview(device);
 }
 
 QVector<QStringList> JsonFilter::preview(QJsonDocument& doc) {
 	return d->preview(doc);
 }
 
 /*!
 writes the content of the data source \c dataSource to the file \c fileName.
 */
 void JsonFilter::write(const QString& fileName, AbstractDataSource* dataSource) {
 	d->write(fileName, dataSource);
 }
 
 ///////////////////////////////////////////////////////////////////////
 /*!
 loads the predefined filter settings for \c filterName
 */
 void JsonFilter::loadFilterSettings(const QString& filterName) {
 	Q_UNUSED(filterName);
 }
 
 /*!
 saves the current settings as a new filter with the name \c filterName
 */
 void JsonFilter::saveFilterSettings(const QString& filterName) const {
 	Q_UNUSED(filterName);
 }
 
 /*!
 returns the list of all predefined data types.
 */
 QStringList JsonFilter::dataTypes() {
 	const QMetaObject& mo = AbstractColumn::staticMetaObject;
 	const QMetaEnum& me = mo.enumerator(mo.indexOfEnumerator("ColumnMode"));
 	QStringList list;
 	for (int i = 0; i <= 100; ++i)	// me.keyCount() does not work because we have holes in enum
 		if (me.valueToKey(i))
 			list << me.valueToKey(i);
 	return list;
 }
 
 /*!
 returns the list of all predefined data row types.
 */
 QStringList JsonFilter::dataRowTypes() {
 	return (QStringList() << "Array" << "Object");
 }
 
 void JsonFilter::setDataRowType(QJsonValue::Type type) {
 	d->rowType = type;
 }
 QJsonValue::Type JsonFilter::dataRowType() const {
 	return d->rowType;
 }
 
 void JsonFilter::setModelRows(QVector<int> rows){
 	d->modelRows = rows;
 }
 
 QVector<int> JsonFilter::modelRows() const {
 	return d->modelRows;
 }
 
 void JsonFilter::setDateTimeFormat(const QString &f) {
 	d->dateTimeFormat = f;
 }
 QString JsonFilter::dateTimeFormat() const {
 	return d->dateTimeFormat;
 }
 
 void JsonFilter::setNumberFormat(QLocale::Language lang) {
 	d->numberFormat = lang;
 }
 QLocale::Language JsonFilter::numberFormat() const {
 	return d->numberFormat;
 }
 
 void JsonFilter::setNaNValueToZero(bool b) {
 	if (b)
 		d->nanValue = 0;
 	else
 		d->nanValue = NAN;
 }
 bool JsonFilter::NaNValueToZeroEnabled() const {
 	if (d->nanValue == 0)
 		return true;
 	return false;
 }
 
 void JsonFilter::setCreateIndexEnabled(bool b){
 	d->createIndexEnabled = b;
 }
 
 void JsonFilter::setImportObjectNames(bool b) {
 	d->importObjectNames = b;
 }
 
 void JsonFilter::setVectorNames(const QString& s) {
 	d->vectorNames.clear();
 	if (!s.simplified().isEmpty())
 		d->vectorNames = s.simplified().split(' ');
 }
 QStringList JsonFilter::vectorNames() const {
 	return d->vectorNames;
 }
 
 QVector<AbstractColumn::ColumnMode> JsonFilter::columnModes() {
 	return d->columnModes;
 }
 
 void JsonFilter::setStartRow(const int r) {
 	d->startRow = r;
 }
 int JsonFilter::startRow() const {
 	return d->startRow;
 }
 
 void JsonFilter::setEndRow(const int r) {
 	d->endRow = r;
 }
 int JsonFilter::endRow() const {
 	return d->endRow;
 }
 
 void JsonFilter::setStartColumn(const int c) {
 	d->startColumn = c;
 }
 int JsonFilter::startColumn() const {
 	return d->startColumn;
 }
 
 void JsonFilter::setEndColumn(const int c) {
 	d->endColumn = c;
 }
 int JsonFilter::endColumn() const {
 	return d->endColumn;
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 JsonFilterPrivate::JsonFilterPrivate(JsonFilter* owner) : q(owner),
 	model(new QJsonModel()),
 	containerType(JsonFilter::Object),
 	rowType(QJsonValue::Object),
 	numberFormat(QLocale::C),
 	createIndexEnabled(false),
 	importObjectNames(false),
 	vectorNames(),
 	startRow(1),
 	endRow(-1),
 	startColumn(1),
 	endColumn(-1),
 	m_actualRows(0),
 	m_actualCols(0),
 	m_prepared(false),
 	m_columnOffset(0) {
 }
 //TODO: delete model from memory
 
 /*!
 returns 1 if row is invalid and 0 otherwise.
 */
 int JsonFilterPrivate::checkRow(QJsonValueRef value, int& countCols) {
 	switch(rowType){
 		//TODO: implement other value types
 		case QJsonValue::Array: {
 			QJsonArray row = value.toArray();
 			if(row.isEmpty())
 				return 1;
 			countCols = (countCols == -1 || countCols > row.count()) ? row.count() : countCols;
 			break;
 		}
 		case QJsonValue::Object: {
 			QJsonObject row = value.toObject();
 			if(row.isEmpty())
 				return 1;
 			countCols = (countCols == -1 || countCols > row.count()) ? row.count() : countCols;
 			break;
 		}
 		case QJsonValue::Double:
 		case QJsonValue::String:
 		case QJsonValue::Bool:
 		case QJsonValue::Null:
 		case QJsonValue::Undefined:
 			return 1;
 	}
 	return 0;
 }
 
 /*!
 returns -1 if a parse error has occurred, 1 if the current row type not supported and 0 otherwise.
 */
 int JsonFilterPrivate::parseColumnModes(QJsonValue row, QString rowName) {
 	columnModes.resize(m_actualCols);
 
 	int colIndexInContainer = startColumn - 1;
 	for(int i = 0; i < m_actualCols; ++i) {
 		if(i == 0 && (createIndexEnabled || importObjectNames)) {
 			//add index column if required
 			if(createIndexEnabled)
 				columnModes[0] = AbstractColumn::Integer;
 
 			//add column for object names if required
 			if(importObjectNames)
 				columnModes[(int)createIndexEnabled] = AbstractFileFilter::columnMode(rowName, dateTimeFormat, numberFormat);
 
 			i = createIndexEnabled + importObjectNames - 1;
 			continue;
 		}
 
 		QJsonValue columnValue;
 		switch (rowType) {
 			//TODO: implement other value types
 			case QJsonValue::Array: {
 				QJsonArray arr = row.toArray();
 				if(arr.count() < colIndexInContainer + 1)
 					return -1;
 				columnValue = *(row.toArray().begin() + colIndexInContainer);
 				break;
 			}
 			case QJsonValue::Object: {
 				QJsonObject obj = row.toObject();
 				if(obj.count() < colIndexInContainer + 1)
 					return -1;
 				if(vectorNames.count() == 0) {
 					vectorNames = row.toObject().keys();
 					for (int i = 1; i < startColumn; i++)
 						vectorNames.removeFirst();
 				}
 				columnValue = *(row.toObject().begin() + colIndexInContainer);
 				break;
 			}
 			case QJsonValue::Double:
 			case QJsonValue::String:
 			case QJsonValue::Bool:
 			case QJsonValue::Null:
 			case QJsonValue::Undefined:
 				return 1;
 		}
 
 		switch (columnValue.type()) {
 			case QJsonValue::Double:
 				columnModes[i] = AbstractColumn::Numeric;
 				break;
 			case QJsonValue::String:
 				columnModes[i] = AbstractFileFilter::columnMode(columnValue.toString(), dateTimeFormat, numberFormat);
 				break;
 			case QJsonValue::Array:
 			case QJsonValue::Object:
 			case QJsonValue::Bool:
 			case QJsonValue::Null:
 			case QJsonValue::Undefined:
 				return -1;
 		}
 		colIndexInContainer++;
 	}
 
 	if(importObjectNames) {
 		const AbstractColumn::ColumnMode mode = columnModes[(int)createIndexEnabled];
 		if (mode == AbstractColumn::DateTime)
 			vectorNames.prepend(QLatin1String("timestamp"));
 		else if (mode == AbstractColumn::Month)
 			vectorNames.prepend(QLatin1String("month"));
 		if (mode == AbstractColumn::Day)
 			vectorNames.prepend(QLatin1String("day"));
 		else
 			vectorNames.prepend(QLatin1String("name"));
 	}
 
 	if(createIndexEnabled)
 		vectorNames.prepend(QLatin1String("index"));
 
 	return 0;
 }
 
 void JsonFilterPrivate::setEmptyValue(int column, int row){
 	switch (columnModes[column]) {
 		case AbstractColumn::Numeric:
 			static_cast<QVector<double>*>(m_dataContainer[column])->operator[](row) = nanValue;
 			break;
 		case AbstractColumn::Integer:
 			static_cast<QVector<int>*>(m_dataContainer[column])->operator[](row) = 0;
 			break;
 		case AbstractColumn::DateTime:
 			static_cast<QVector<QDateTime>*>(m_dataContainer[column])->operator[](row) = QDateTime();
 			break;
 		case AbstractColumn::Text:
 			static_cast<QVector<QString>*>(m_dataContainer[column])->operator[](row) = "";
 			break;
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 			break;
 	}
 }
 
 void JsonFilterPrivate::setValueFromString(int column, int row, QString valueString){
 	QLocale locale(numberFormat);
 	switch (columnModes[column]) {
 		case AbstractColumn::Numeric: {
 			bool isNumber;
 			const double value = locale.toDouble(valueString, &isNumber);
 			static_cast<QVector<double>*>(m_dataContainer[column])->operator[](row) = isNumber ? value : nanValue;
 			break;
 		}
 		case AbstractColumn::Integer: {
 			bool isNumber;
 			const int value = locale.toInt(valueString, &isNumber);
 			static_cast<QVector<int>*>(m_dataContainer[column])->operator[](row) = isNumber ? value : 0;
 			break;
 		}
 		case AbstractColumn::DateTime: {
 			const QDateTime valueDateTime = QDateTime::fromString(valueString, dateTimeFormat);
 			static_cast<QVector<QDateTime>*>(m_dataContainer[column])->operator[](row) =
 					valueDateTime.isValid() ? valueDateTime : QDateTime();
 			break;
 		}
 		case AbstractColumn::Text:
 			static_cast<QVector<QString>*>(m_dataContainer[column])->operator[](row) = valueString;
 			break;
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 			break;
 	}
 }
 
 /*!
 returns -1 if the device couldn't be opened, 1 if the current read position in the device is at the end
 */
 int JsonFilterPrivate::prepareDeviceToRead(QIODevice& device) {
 	DEBUG("device is sequential = " << device.isSequential());
 
 	if (!device.open(QIODevice::ReadOnly))
 		return -1;
 
 	if (device.atEnd() && !device.isSequential()) // empty file
 		return 1;
 
 	QJsonParseError err;
 	QJsonDocument doc = QJsonDocument::fromJson(device.readAll(), &err);
 
 	if(err.error != QJsonParseError::NoError || doc.isEmpty())
 		return 1;
 
 	if(prepareDocumentToRead(doc) != 0)
 		return 2;
 	// reset to start of file
 	if (!device.isSequential())
 		device.seek(0);
 
 	return 0;
 }
 
 /*!
 returns 2 if a parse error has occurred and 0 otherwise.
 */
 int JsonFilterPrivate::prepareDocumentToRead(const QJsonDocument& doc) {
 	model->loadJson(doc);
 
 	if (modelRows.isEmpty())
 		m_preparedDoc = doc;
 	else {
 		QModelIndex index;
-		for (auto it = modelRows.begin(); it != modelRows.end(); ++it) {
-			index = model->index(*it, 0, index);
+		for (auto& it : modelRows) {
+			index = model->index(it, 0, index);
 		}
 		m_preparedDoc = model->genJsonByIndex(index);
 	}
 
 	if (!m_preparedDoc.isEmpty()) {
 		if (m_preparedDoc.isArray())
 			containerType = JsonFilter::Array;
 		else if (m_preparedDoc.isObject())
 			containerType = JsonFilter::Object;
 		else
 			return 2;
 	} else
 		return 2;
 
 	int countRows = 0;
 	int countCols = -1;
 	QJsonValue firstRow;
 	QString firstRowName = "";
 	importObjectNames = importObjectNames && rowType == QJsonValue::Object;
 
 	switch(containerType) {
 		case JsonFilter::Array: {
 			QJsonArray arr = m_preparedDoc.array();
 
 			if(arr.count() < startRow)
 				return 2;
 
 			int endRowOffset = (endRow == -1 || endRow > arr.count()) ? arr.count() : endRow;
 			firstRow = *(arr.begin() + (startRow - 1));
 			for(QJsonArray::iterator it = arr.begin() + (startRow - 1); it != arr.begin() + endRowOffset; ++it) {
 				if(checkRow(*it, countCols) != 0)
 					return 2;
 				countRows++;
 			}
 			break;
 		}
 		case JsonFilter::Object: {
 			QJsonObject obj = m_preparedDoc.object();
 
 			if(obj.count() < startRow)
 				return 2;
 
 			int startRowOffset = startRow - 1;
 			int endRowOffset = (endRow == -1 || endRow > obj.count()) ? obj.count() : endRow;
 			firstRow = *(obj.begin() + startRowOffset);
 			firstRowName = (obj.begin() + startRowOffset).key();
 			for(QJsonObject::iterator it = obj.begin() + startRowOffset; it != obj.begin() + endRowOffset; ++it) {
 				if(checkRow(*it, countCols) != 0)
 					return 2;
 				countRows++;
 			}
 			break;
 		}
 	}
 
 	if(endColumn == -1 || endColumn > countCols)
 		endColumn = countCols;
 
 	m_actualRows = countRows;
 	m_actualCols = endColumn - startColumn + 1 + createIndexEnabled + importObjectNames;
 
 	if(parseColumnModes(firstRow, firstRowName) != 0)
 		return 2;
 
 	DEBUG("start/end column: = " << startColumn << ' ' << endColumn);
 	DEBUG("start/end rows = " << startRow << ' ' << endRow);
 	DEBUG("actual cols/rows = " << m_actualCols << ' ' << m_actualRows);
 
 	return 0;
 }
 
 /*!
 reads the content of the file \c fileName to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void JsonFilterPrivate::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode) {
 	 KFilterDev device(fileName);
 	 readDataFromDevice(device, dataSource, importMode);
 }
 
 /*!
 reads the content of device \c device to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void JsonFilterPrivate::readDataFromDevice(QIODevice& device, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	if(!m_prepared) {
 		const int deviceError = prepareDeviceToRead(device);
 		if(deviceError != 0){
 			DEBUG("Device error = " << deviceError);
 			return;
 		}
 		//TODO: support other modes and vector names
 		m_prepared = true;
 	}
 	importData(dataSource, importMode, lines);
 }
 
 /*!
 reads the content of document \c doc to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void JsonFilterPrivate::readDataFromDocument(const QJsonDocument& doc, AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	if(!m_prepared) {
 		const int docError = prepareDocumentToRead(doc);
 		if(docError != 0){
 			DEBUG("Document parse error = " << docError);
 			return;
 		}
 		//TODO: support other modes and vector names
 		m_prepared = true;
 	}
 	importData(dataSource, importMode, lines);
 }
 
 /*!
 import the content of document \c m_preparedDoc to the data source \c dataSource. Uses the settings defined in the data source.
 */
 void JsonFilterPrivate::importData(AbstractDataSource* dataSource, AbstractFileFilter::ImportMode importMode, int lines) {
 	Q_UNUSED(lines)
 
 	m_columnOffset = dataSource->prepareImport(m_dataContainer, importMode, m_actualRows, m_actualCols, vectorNames, columnModes);
 	int rowOffset = startRow - 1;
 	DEBUG("reading " << m_actualRows << " lines");
 	for(int i = 0; i < m_actualRows; ++i) {
 		QString rowName;
 		QJsonValue row;
 		switch (containerType) {
 			case JsonFilter::Array:
 				row = *(m_preparedDoc.array().begin() + rowOffset + i);
 				break;
 			case JsonFilter::Object:
 				rowName = (m_preparedDoc.object().begin() + rowOffset + i).key();
 				row = *(m_preparedDoc.object().begin() + rowOffset + i);
 				break;
 		}
 
 		int colIndex = startColumn - 1;
 		for(int n = 0; n < m_actualCols; ++n) {
 			if((createIndexEnabled || importObjectNames) && n == 0) {
 				if(createIndexEnabled)
 					static_cast<QVector<int>*>(m_dataContainer[n])->operator[](i) = i + 1;
 				if(importObjectNames)
 					setValueFromString(n + createIndexEnabled, i, rowName);
 				n = n + createIndexEnabled + importObjectNames - 1;
 				continue;
 			}
 			QJsonValue value;
 			switch(rowType){
 				//TODO: implement other value types
 				case QJsonValue::Array: {
 					value = *(row.toArray().begin() + colIndex);
 					break;
 				}
 				case QJsonValue::Object: {
 					value = *(row.toObject().begin() + colIndex);
 					break;
 				}
 				case QJsonValue::Double:
 				case QJsonValue::String:
 				case QJsonValue::Bool:
 				case QJsonValue::Null:
 				case QJsonValue::Undefined:
 					break;
 			}
 
 			switch(value.type()) {
 				case QJsonValue::Double:
 					if(columnModes[n] == AbstractColumn::Numeric)
 						static_cast<QVector<double>*>(m_dataContainer[n])->operator[](i) = value.toDouble();
 					else
 						setEmptyValue(n, i + startRow - 1);
 					break;
 				case QJsonValue::String:
 					setValueFromString(n, i, value.toString());
 					break;
 				case QJsonValue::Array:
 				case QJsonValue::Object:
 				case QJsonValue::Bool:
 				case QJsonValue::Null:
 				case QJsonValue::Undefined:
 					setEmptyValue(n, i + startRow - 1);
 					break;
 			}
 			colIndex++;
 		}
 		emit q->completed(100 * i/m_actualRows);
 	}
 	//TODO: fix (startColumn + m_actualCols - 1)
 	dataSource->finalizeImport(m_columnOffset, startColumn, startColumn + m_actualCols - 1, m_actualRows, dateTimeFormat, importMode);
 }
 
 /*!
 generates the preview for the file \c fileName.
 */
 QVector<QStringList> JsonFilterPrivate::preview(const QString& fileName) {
 	KFilterDev device(fileName);
 	return preview(device);
 }
 
 /*!
 generates the preview for device \c device.
 */
 QVector<QStringList> JsonFilterPrivate::preview(QIODevice &device) {
 	const int deviceError = prepareDeviceToRead(device);
 	if (deviceError != 0) {
 		DEBUG("Device error = " << deviceError);
 		return QVector<QStringList>();
 	}
 
 	return preview();
 }
 
 /*!
 generates the preview for document \c doc.
 */
 QVector<QStringList> JsonFilterPrivate::preview(QJsonDocument &doc) {
 	if(prepareDocumentToRead(doc) != 0)
 		return QVector<QStringList>();
 	return preview();
 }
 
 /*!
 generates the preview for document \c m_preparedDoc.
 */
 QVector<QStringList> JsonFilterPrivate::preview() {
 	QVector<QStringList> dataStrings;
 	const int rowOffset = startRow - 1;
 	DEBUG("reading " << m_actualRows << " lines");
 	for(int i = 0; i < m_actualRows; ++i) {
 		QString rowName;
 		QJsonValue row;
 		switch (containerType) {
 			case JsonFilter::Object:
 				rowName = (m_preparedDoc.object().begin() + rowOffset + i).key();
 				row = *(m_preparedDoc.object().begin() + rowOffset + i);
 				break;
 			case JsonFilter::Array:
 				row = *(m_preparedDoc.array().begin() + rowOffset + i);
 				break;
 		}
 
 		QStringList lineString;
 		int colIndex = startColumn - 1;
 		for(int n = 0; n < m_actualCols; ++n) {
 			if((createIndexEnabled || importObjectNames) && n == 0) {
 				if(createIndexEnabled)
 					lineString += QString::number(i + 1);
 				if(importObjectNames)
 					lineString += rowName;
 				n = n + createIndexEnabled + importObjectNames - 1;
 				continue;
 			}
 
 			QJsonValue value;
 			switch(rowType){
 				case QJsonValue::Object: {
 					value = *(row.toObject().begin() + colIndex);
 					break;
 				}
 				case QJsonValue::Array: {
 					value = *(row.toArray().begin() + colIndex);
 					break;
 				}
 					//TODO: implement other value types
 				case QJsonValue::Double:
 				case QJsonValue::String:
 				case QJsonValue::Bool:
 				case QJsonValue::Null:
 				case QJsonValue::Undefined:
 					break;
 			}
 			switch(value.type()) {
 				case QJsonValue::Double:
 					if(columnModes[n] == AbstractColumn::Numeric)
 						lineString += QString::number(value.toDouble(), 'g', 16);
 					else
 						lineString += lineString += QLatin1String("");
 					break;
 				case QJsonValue::String: {
 					//TODO: add parsing string before appending
 					lineString += value.toString();
 					break;
 				}
 				case QJsonValue::Array:
 				case QJsonValue::Object:
 				case QJsonValue::Bool:
 				case QJsonValue::Null:
 				case QJsonValue::Undefined:
 					lineString += QLatin1String("");
 					break;
 			}
 			colIndex++;
 		}
 		dataStrings << lineString;
 		emit q->completed(100 * i/m_actualRows);
 	}
 	return dataStrings;
 }
 
 /*!
 writes the content of \c dataSource to the file \c fileName.
 */
 void JsonFilterPrivate::write(const QString& fileName, AbstractDataSource* dataSource) {
 	Q_UNUSED(fileName);
 	Q_UNUSED(dataSource);
 
 	//TODO: save data to json file
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 /*!
 Saves as XML.
 */
 void JsonFilter::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("jsonFilter");
 	writer->writeAttribute("rowType", QString::number(d->rowType));
 	writer->writeAttribute("dateTimeFormat", d->dateTimeFormat);
 	writer->writeAttribute("numberFormat", QString::number(d->numberFormat));
 	writer->writeAttribute("createIndex", QString::number(d->createIndexEnabled));
 	writer->writeAttribute("importObjectNames", QString::number(d->importObjectNames));
 	writer->writeAttribute("nanValue", QString::number(d->nanValue));
 	writer->writeAttribute("startRow", QString::number(d->startRow));
 	writer->writeAttribute("endRow", QString::number(d->endRow));
 	writer->writeAttribute("startColumn", QString::number(d->startColumn));
 	writer->writeAttribute("endColumn", QString::number(d->endColumn));
 
 	QStringList list;
-	for(auto it = modelRows().begin(); it != modelRows().end(); ++it){
-		list.append(QString::number(*it));
-	}
+	for (auto& it : modelRows())
+		list.append(QString::number(it));
+
 	writer->writeAttribute("modelRows", list.join(';'));
 
 	writer->writeEndElement();
 	DEBUG("JsonFilter save params");
 }
 
 /*!
 Loads from XML.
 */
 bool JsonFilter::load(XmlStreamReader* reader) {
 	QString attributeWarning = i18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs = reader->attributes();
 
 	QString str = attribs.value("rowType").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'rowType'"));
 	else
 		d->rowType = static_cast<QJsonValue::Type>(str.toInt());
 
 	str = attribs.value("dateTimeFormat").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'dateTimeFormat'"));
 	else
 		d->dateTimeFormat = str;
 
 	str = attribs.value("numberFormat").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'numberFormat'"));
 	else
 		d->numberFormat = static_cast<QLocale::Language >(str.toInt());
 
 	str = attribs.value("createIndex").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'createIndex'"));
 	else
 		d->createIndexEnabled = str.toInt();
 
 	str = attribs.value("importObjectNames").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'importObjectNames'"));
 	else
 		d->importObjectNames = str.toInt();
 
 	str = attribs.value("nanValue").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'nanValue'"));
 	else
 		d->nanValue = str.toDouble();
 
 	str = attribs.value("startRow").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'startRow'"));
 	else
 		d->startRow = str.toInt();
 
 	str = attribs.value("endRow").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'endRow'"));
 	else
 		d->endRow = str.toInt();
 
 	str = attribs.value("startColumn").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'startColumn'"));
 	else
 		d->startColumn = str.toInt();
 
 	str = attribs.value("endColumn").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'endColumn'"));
 	else
 		d->endColumn = str.toInt();
 
 	QStringList list = attribs.value("modelRows").toString().split(';');
 	if (list.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'modelRows'"));
 	else{
 		d->modelRows = QVector<int>();
-		for (auto& it: list)
+		for (auto& it : list)
 			d->modelRows.append(it.toInt());
 	}
 
 	DEBUG("JsonFilter load params");
 	return true;
 }
diff --git a/src/backend/datasources/filters/QJsonModel.cpp b/src/backend/datasources/filters/QJsonModel.cpp
index d7dee158d..6b920513c 100644
--- a/src/backend/datasources/filters/QJsonModel.cpp
+++ b/src/backend/datasources/filters/QJsonModel.cpp
@@ -1,350 +1,350 @@
 /*
  * The MIT License (MIT)
  *
  * Copyright (c) 2011 SCHUTZ Sacha
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
 
 #include "QJsonModel.h"
 
 #include <QApplication>
 #include <QDebug>
 #include <QFile>
 #include <QPalette>
 
 QJsonTreeItem::QJsonTreeItem(QJsonTreeItem* parent) : mParent(parent) {
 }
 
 QJsonTreeItem::~QJsonTreeItem() {
 	qDeleteAll(mChilds);
 }
 
 void QJsonTreeItem::appendChild(QJsonTreeItem* item) {
 	mChilds.append(item);
 }
 
 QJsonTreeItem* QJsonTreeItem::child(int row) {
 	return mChilds.value(row);
 }
 
 QJsonTreeItem* QJsonTreeItem::parent() {
 	return mParent;
 }
 
 int QJsonTreeItem::childCount() const {
 	return mChilds.count();
 }
 
 int QJsonTreeItem::row() const {
 	if (mParent)
 		return mParent->mChilds.indexOf(const_cast<QJsonTreeItem*>(this));
 
 	return 0;
 }
 
 void QJsonTreeItem::setKey(const QString& key) {
 	mKey = key;
 }
 
 void QJsonTreeItem::setValue(const QString& value) {
 	mValue = value;
 }
 
 void QJsonTreeItem::setType(const QJsonValue::Type type) {
 	mType = type;
 }
 
 QString QJsonTreeItem::key() const {
 	return mKey;
 }
 
 QString QJsonTreeItem::value() const {
 	return mValue;
 }
 
 QJsonValue::Type QJsonTreeItem::type() const {
 	return mType;
 }
 
 QJsonTreeItem* QJsonTreeItem::load(const QJsonValue& value, QJsonTreeItem* parent) {
 	QJsonTreeItem* rootItem = new QJsonTreeItem(parent);
 	rootItem->setKey("root");
 
 	if ( value.isObject()) {
 
 		//Get all QJsonValue childs
 		for (QString key : value.toObject().keys()) {
 			QJsonValue v = value.toObject().value(key);
 			QJsonTreeItem* child = load(v,rootItem);
 			child->setKey(key);
 			child->setType(v.type());
 			rootItem->appendChild(child);
 		}
 	} else if ( value.isArray()) {
 		//Get all QJsonValue childs
 		int index = 0;
 		for (QJsonValue v : value.toArray()) {
 			QJsonTreeItem* child = load(v,rootItem);
 			child->setKey(QString::number(index));
 			child->setType(v.type());
 			rootItem->appendChild(child);
 			++index;
 		}
 	} else {
 		rootItem->setValue(value.toVariant().toString());
 		rootItem->setType(value.type());
 	}
 
 	return rootItem;
 }
 
 //=========================================================================
 
 QJsonModel::QJsonModel(QObject* parent) : QAbstractItemModel(parent),
 	mHeadItem(new QJsonTreeItem),
 	mRootItem(new QJsonTreeItem(mHeadItem)) {
 
 	mHeadItem->appendChild(mRootItem);
 	mHeaders.append("key");
 	mHeaders.append("value");
 }
 
 QJsonModel::~QJsonModel() {
 	//delete mRootItem;
 	delete mHeadItem;
 }
 
 void QJsonModel::clear() {
 	beginResetModel();
 	delete mHeadItem;
 	mHeadItem = new QJsonTreeItem;
 	mRootItem = new QJsonTreeItem(mHeadItem);
 	mHeadItem->appendChild(mRootItem);
 	endResetModel();
 }
 
 bool QJsonModel::load(const QString& fileName) {
 	QFile file(fileName);
 	bool success = false;
 	if (file.open(QIODevice::ReadOnly)) {
 		success = load(&file);
 		file.close();
 	} else
 		success = false;
 
 	return success;
 }
 
 bool QJsonModel::load(QIODevice* device) {
 	return loadJson(device->readAll());
 }
 
 bool QJsonModel::loadJson(const QByteArray& json) {
 	auto const& jdoc = QJsonDocument::fromJson(json);
 	return loadJson(jdoc);
 }
 
 bool QJsonModel::loadJson(const QJsonDocument& jdoc) {
 	if (!jdoc.isNull()) {
 		beginResetModel();
 		delete mHeadItem;
 
 		mHeadItem = new QJsonTreeItem;
 
 		if (jdoc.isArray()) {
 			mRootItem = QJsonTreeItem::load(QJsonValue(jdoc.array()), mHeadItem);
 			mRootItem->setType(QJsonValue::Array);
 
 		} else {
 			mRootItem = QJsonTreeItem::load(QJsonValue(jdoc.object()), mHeadItem);
 			mRootItem->setType(QJsonValue::Object);
 		}
 
 		mHeadItem->appendChild(mRootItem);
 
 		endResetModel();
 		return true;
 	}
 
 	qDebug()<<Q_FUNC_INFO<<"cannot load json";
 	return false;
 }
 
 QVariant QJsonModel::data(const QModelIndex& index, int role) const {
 	if (!index.isValid())
 		return QVariant();
 
 	QJsonTreeItem* item = static_cast<QJsonTreeItem*>(index.internalPointer());
 
 	if (role == Qt::DisplayRole) {
 		if (index.column() == 0)
 			return QString("%1").arg(item->key());
 
 		if (index.column() == 1)
 			return QString("%1").arg(item->value());
 	} else if (Qt::EditRole == role) {
 		if (index.column() == 1)
 			return QString("%1").arg(item->value());
 	} else if (role == Qt::DecorationRole) {
 		if (index.column() == 0) {
 			QIcon icon;
 			if (item->type() == QJsonValue::Array)
 				icon = QIcon::fromTheme("labplot-json-array");
 			else if (item->type() == QJsonValue::Object)
 				icon = QIcon::fromTheme("labplot-json-object");
 
 			if (qApp->palette().color(QPalette::Base).lightness() < 128) {
 				//dark theme is used -> invert the icons which use black colors
 				QImage image = icon.pixmap(64, 64).toImage(); //TODO: use different(standard?) pixel size?
 				image.invertPixels();
 				icon = QIcon(QPixmap::fromImage(image));
 			}
 			return icon;
 		}
 		return QIcon();
 	}
 
 	return QVariant();
 }
 
 bool QJsonModel::setData(const QModelIndex& index, const QVariant& value, int role) {
 	if (Qt::EditRole == role) {
 		if (index.column() == 1) {
 			QJsonTreeItem* item = static_cast<QJsonTreeItem*>(index.internalPointer());
 			item->setValue(value.toString());
 			emit dataChanged(index, index, {Qt::EditRole});
 			return true;
 		}
 	}
 
 	return false;
 }
 
 QVariant QJsonModel::headerData(int section, Qt::Orientation orientation, int role) const {
 	if (role != Qt::DisplayRole)
 		return QVariant();
 
 	if (orientation == Qt::Horizontal)
 		return mHeaders.value(section);
 
 	return QVariant();
 }
 
 QModelIndex QJsonModel::index(int row, int column, const QModelIndex& parent) const {
 	if (!hasIndex(row, column, parent))
 		return QModelIndex{};
 
 	QJsonTreeItem* parentItem;
 
 	if (!parent.isValid())
 		parentItem = mHeadItem;
 	else
 		parentItem = static_cast<QJsonTreeItem*>(parent.internalPointer());
 
 	QJsonTreeItem* childItem = parentItem->child(row);
 	if (childItem)
 		return createIndex(row, column, childItem);
 
 	return QModelIndex{};
 }
 
 QModelIndex QJsonModel::parent(const QModelIndex& index) const {
 	if (!index.isValid())
 		return QModelIndex{};
 
 	QJsonTreeItem* childItem = static_cast<QJsonTreeItem*>(index.internalPointer());
 	QJsonTreeItem* parentItem = childItem->parent();
 
 	if (parentItem == mHeadItem)
 		return QModelIndex{};
 
 	return createIndex(parentItem->row(), 0, parentItem);
 }
 
 int QJsonModel::rowCount(const QModelIndex& parent) const {
 	QJsonTreeItem* parentItem;
 	if (parent.column() > 0)
 		return 0;
 
 	if (!parent.isValid())
 		parentItem = mHeadItem;
 	else
 		parentItem = static_cast<QJsonTreeItem*>(parent.internalPointer());
 
 	return parentItem->childCount();
 }
 
 int QJsonModel::columnCount(const QModelIndex& parent) const {
 	Q_UNUSED(parent)
 	return 2;
 }
 
 Qt::ItemFlags QJsonModel::flags(const QModelIndex& index) const {
 	if (index.column() == 1)
 		return Qt::ItemIsEditable | QAbstractItemModel::flags(index);
 	else
 		return QAbstractItemModel::flags(index);
 }
 
 QJsonDocument QJsonModel::json() const {
 	auto v = genJson(mRootItem);
 	QJsonDocument doc;
 
 	if (v.isObject())
 		doc = QJsonDocument(v.toObject());
 	else
 		doc = QJsonDocument(v.toArray());
 
 	return doc;
 }
 
 QJsonValue  QJsonModel::genJson(QJsonTreeItem* item) const {
-	auto type   = item->type();
-	const int  nchild = item->childCount();
+	auto type = item->type();
+	const int nchild = item->childCount();
 
 	if (QJsonValue::Object == type) {
 		QJsonObject jo;
 		for (int i = 0; i < nchild; ++i) {
 			auto ch = item->child(i);
 			auto key = ch->key();
 			jo.insert(key, genJson(ch));
 		}
 		return  jo;
 	} else if (QJsonValue::Array == type) {
 		QJsonArray arr;
 		for (int i = 0; i < nchild; ++i) {
 			auto ch = item->child(i);
 			arr.append(genJson(ch));
 		}
 		return arr;
 	} else {
 		QJsonValue va(item->value());
 		return va;
 	}
 
 }
 
 QJsonDocument QJsonModel::genJsonByIndex(const QModelIndex& index) const {
 	if (!index.isValid())
 		return QJsonDocument();
 
 	QJsonTreeItem* item = static_cast<QJsonTreeItem*>(index.internalPointer());
 	return QJsonDocument::fromVariant(genJson(item).toVariant());
 }
diff --git a/src/backend/datasources/filters/ROOTFilter.cpp b/src/backend/datasources/filters/ROOTFilter.cpp
index a032640f9..eaf69d719 100644
--- a/src/backend/datasources/filters/ROOTFilter.cpp
+++ b/src/backend/datasources/filters/ROOTFilter.cpp
@@ -1,645 +1,645 @@
 /***************************************************************************
 File                 : ROOTFilter.cpp
 Project              : LabPlot
 Description          : ROOT(CERN) I/O-filter
 --------------------------------------------------------------------
 Copyright            : (C) 2018 by Christoph Roick (chrisito@gmx.de)
 ***************************************************************************/
 
 /***************************************************************************
 *                                                                         *
 *  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/filters/ROOTFilter.h"
 #include "backend/datasources/filters/ROOTFilterPrivate.h"
 #include "backend/datasources/AbstractDataSource.h"
 #include "backend/core/column/Column.h"
 
 #include <KLocalizedString>
 
 #ifdef HAVE_ZIP
 
 #include <lz4.h>
 #include <zlib.h>
 
 #endif
 
 #include <cmath>
 #include <fstream>
 #include <limits>
 #include <map>
 #include <string>
 #include <vector>
 
 ROOTFilter::ROOTFilter():AbstractFileFilter(), d(new ROOTFilterPrivate) {}
 
 ROOTFilter::~ROOTFilter() = default;
 
 void ROOTFilter::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource,
 			AbstractFileFilter::ImportMode importMode) {
 	d->readDataFromFile(fileName, dataSource, importMode);
 }
 
 void ROOTFilter::write(const QString& fileName, AbstractDataSource* dataSource) {
 	d->write(fileName, dataSource);
 }
 
 void ROOTFilter::loadFilterSettings(const QString& filterName) {
 	Q_UNUSED(filterName);
 }
 
 void ROOTFilter::saveFilterSettings(const QString& filterName) const {
 	Q_UNUSED(filterName);
 }
 
 void ROOTFilter::setCurrentHistogram(const QString& histogram) {
 	d->currentHistogram = histogram;
 }
 
 const QString ROOTFilter::currentHistogram() const {
 	return d->currentHistogram;
 }
 
 QStringList ROOTFilter::listHistograms(const QString& fileName) {
 	return d->listHistograms(fileName);
 }
 
 QVector<QStringList> ROOTFilter::previewCurrentHistogram(const QString& fileName,
                                                          int first, int last) {
 	return d->previewCurrentHistogram(fileName, first, last);
 }
 
 int ROOTFilter::binsInCurrentHistogram(const QString& fileName) {
 	return d->binsInCurrentHistogram(fileName);
 }
 
 void ROOTFilter::setStartBin(const int s) {
 	d->startBin = s;
 }
 
 int ROOTFilter::startBin() const {
 	return d->startBin;
 }
 
 void ROOTFilter::setEndBin(const int e) {
 	d->endBin = e;
 }
 
 int ROOTFilter::endBin() const {
 	return d->endBin;
 }
 
 void ROOTFilter::setColumns(const int columns) {
 	d->columns = columns;
 }
 
 int ROOTFilter::columns() const {
 	return d->columns;
 }
 
 void ROOTFilter::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("rootFilter");
 	writer->writeAttribute("startBin", QString::number(d->startBin) );
 	writer->writeAttribute("endBin", QString::number(d->endBin) );
 	writer->writeAttribute("columns", QString::number(d->columns) );
 	writer->writeEndElement();
 }
 
 bool ROOTFilter::load(XmlStreamReader* reader) {
 	QString attributeWarning = i18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs = reader->attributes();
 
 	// read attributes
 	QString str = attribs.value("startBin").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'startBin'"));
 	else
 		d->startBin = str.toInt();
 
 	str = attribs.value("endBin").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'endBin'"));
 	else
 		d->endBin = str.toInt();
 
 	str = attribs.value("columns").toString();
 	if (str.isEmpty())
 		reader->raiseWarning(attributeWarning.arg("'columns'"));
 	else
 		d->columns = str.toInt();
 
 	return true;
 }
 
 /**************** ROOTFilterPrivate implementation *******************/
 
 ROOTFilterPrivate::ROOTFilterPrivate() = default;
 
 void ROOTFilterPrivate::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource,
 		AbstractFileFilter::ImportMode importMode) {
 	DEBUG("ROOTFilterPrivate::readDataFromFile()");
 
 	setFile(fileName);
 
 	auto bins = readHistogram();
 	const int nbins = (int)bins.size();
 
 	// skip underflow and overflow bins by default
 	int first = qMax(startBin, 0);
 	int last = qMin(endBin, nbins - 1);
 
 	QStringList colNames = createHeaders();
 
 	QVector<void*> dataContainer;
 	const int columnOffset = dataSource->prepareImport(dataContainer, importMode, last - first + 1, colNames.size(),
 			colNames, QVector<AbstractColumn::ColumnMode>(colNames.size(), AbstractColumn::Numeric));
 
 	// read data
 	DEBUG("reading " << first - last + 1 << " lines");
 
 	int c = 0;
 	if (columns & ROOTFilter::Center) {
 		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
 		for (int i = first; i <= last; ++i)
 			container[i - first] = (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
 			                                       : i == 0 ? bins.front().lowedge   // -infinity
 			                                                : -bins.front().lowedge; // +infinity
 	}
 	if (columns & ROOTFilter::Low) {
 		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
 		for (int i = first; i <= last; ++i)
 			container[i - first] = bins[i].lowedge;
 	}
 	if (columns & ROOTFilter::Content) {
 		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
 		for (int i = first; i <= last; ++i)
 			container[i - first] = bins[i].content;
 	}
 	if (columns & ROOTFilter::Error) {
 		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
 		for (int i = first; i <= last; ++i)
 			container[i - first] = std::sqrt(bins[i].sumw2);
 	}
 
 	dataSource->finalizeImport(columnOffset, 0, colNames.size() - 1, -1, QString(), importMode);
 }
 
 void ROOTFilterPrivate::write(const QString& fileName, AbstractDataSource* dataSource) {
 	Q_UNUSED(fileName);
 	Q_UNUSED(dataSource);
 	//TODO
 }
 
 QStringList ROOTFilterPrivate::listHistograms(const QString& fileName) {
 	setFile(fileName);
 
 	QStringList histList;
 	for (const auto& hist : currentROOTHist->listHistograms()) {
 		histList << QString::fromStdString(hist);
 	}
 
 	return histList;
 }
 
 QVector<QStringList> ROOTFilterPrivate::previewCurrentHistogram(const QString& fileName, int first, int last) {
 	DEBUG("previewCurrentHistogram()");
 
 	setFile(fileName);
 
 	auto bins = readHistogram();
 	const int nbins = (int)bins.size();
 
 	last = qMin(nbins - 1, last);
 
 	QVector<QStringList> preview(qMax(last - first + 2, 1));
 	preview.last() = createHeaders();
 
 	// read data
 	DEBUG("reading " << preview.size() << " lines");
 
 	if (columns & ROOTFilter::Center) {
 		for (int i = first; i <= last; ++i)
 			preview[i - first] << QString::number(
 			    (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
 			                    : i == 0 ? bins.front().lowedge    // -infinity
 			                             : -bins.front().lowedge); // +infinity
 	}
 	if (columns & ROOTFilter::Low) {
 		for (int i = first; i <= last; ++i)
 			preview[i - first] << QString::number(bins[i].lowedge);
 	}
 	if (columns & ROOTFilter::Content) {
 		for (int i = first; i <= last; ++i)
 			preview[i - first] << QString::number(bins[i].content);
 	}
 	if (columns & ROOTFilter::Error) {
 		for (int i = first; i <= last; ++i)
 			preview[i - first] << QString::number(std::sqrt(bins[i].sumw2));
 	}
 
 	return preview;
 }
 
 int ROOTFilterPrivate::binsInCurrentHistogram(const QString& fileName) {
 	setFile(fileName);
 
 	QStringList nameindex = currentHistogram.split(';');
 	bool ok = nameindex.size() > 1;
 	int cycle = ok ? nameindex.last().toInt(&ok) : 1;
 	if (ok) {
 		nameindex.removeLast();
 	} else {
 		cycle = 1;
 	}
 
 	return currentROOTHist->histogramBins(nameindex.join(';').toStdString(), cycle);
 }
 
 QStringList ROOTFilterPrivate::createHeaders() {
 	QStringList colNames;
 	if (columns & ROOTFilter::Center)
 		colNames << i18n("Bin Center");
 	if (columns & ROOTFilter::Low)
 		colNames << i18n("Low Edge");
 	if (columns & ROOTFilter::Content)
 		colNames << i18n("Content");
 	if (columns & ROOTFilter::Error)
 		colNames << i18n("Error");
 	return colNames;
 }
 
 void ROOTFilterPrivate::setFile(const QString& fileName) {
 	if (!currentROOTHist || fileName != currentFile) {
 		currentFile = fileName;
 		currentROOTHist.reset(new ROOTHist(fileName.toStdString()));
 	}
 }
 
 std::vector<ROOTHist::BinPars> ROOTFilterPrivate::readHistogram() {
 	QStringList nameindex = currentHistogram.split(';');
 	bool ok = nameindex.size() > 1;
 	int cycle = ok ? nameindex.last().toInt(&ok) : 1;
 	if (ok) {
 		nameindex.removeLast();
 	} else {
 		cycle = 1;
 	}
 
 	return currentROOTHist->readHistogram(nameindex.join(';').toStdString(), cycle);
 }
 
 /******************** ROOTHist implementation ************************/
 
 namespace ROOTHistHelpers {
 
 /// Read value from stream
 template<class T>
 T read(std::ifstream& is) {
 	union {
 		T val;
 		char buf[sizeof(T)];
 	} r;
 	for (size_t i = 0; i < sizeof(T); ++i) {
 		r.buf[sizeof(T) - i - 1] = is.get();
 	}
 
 	return r.val;
 }
 
 /// Read value from buffer
 template<class T>
 T read(char*& s) {
 	union {
 		T val;
 		char buf[sizeof(T)];
 	} r;
 	for (size_t i = 0; i < sizeof(T); ++i) {
 		r.buf[sizeof(T) - i - 1] = *(s++);
 	}
 
 	return r.val;
 }
 
 /// Get version of ROOT object, obtain number of bytes in object
 short Version(char*& buffer, size_t& count) {
 	count = read<unsigned int>(buffer);
 	short version = (count & 0x40000000) ? read<short>(buffer) : read<short>(buffer -= 4);
 	count &= (count & 0x40000000) ? (~0x40000000) : 0;
 	return version;
 }
 
 /// Get version of ROOT object
 short Version(char*& buffer) {
 	size_t c;
 	return Version(buffer, c);
 }
 
 /// Skip ROOT object
 void Skip(char*& buffer, const size_t& n) {
 	for (size_t i = 0; i < n; ++i) {
 		char* nbuf = buffer + 4;
 		size_t count;
 		Version(buffer, count);
 		buffer = nbuf + count;
 	}
 }
 
 /// Skip TObject header
 void SkipObject(char*& buffer) {
 	Version(buffer);
 	buffer += 8;
 }
 
 /// Get TString
 std::string String(char*& buffer) {
 	size_t s = *(buffer++);
 	if (s == 0)
 		return std::string();
 	else {
 		if (s == 0xFF)
 			s = read<int>(buffer);
 		buffer += s;
 		return std::string(buffer - s, buffer);
 	}
 }
 
 }
 
 using namespace ROOTHistHelpers;
 
 ROOTHist::ROOTHist(const std::string& filename) : filename(filename) {
 	// The file structure is described in root/io/io/src/TFile.cxx
 	std::ifstream is(filename, std::ifstream::binary);
 	std::string root(4, 0);
 	is.read(const_cast<char*>(root.data()), 4);
 	if (root != "root")
 		return;
 
 	is.seekg(8); // skip version
 	int pos = read<int>(is);
 	is.seekg(16);
 	int lastpos = read<int>(is);
 
 	is.seekg(33);
 	compression = read<int>(is);
 	compression = compression > 0 ? compression : 0;
 
 	while (is.good() && pos < lastpos) {
 		is.seekg(pos);
 		size_t lcdata = read<unsigned int>(is);
 		is.seekg(2, is.cur); // short version = read<short>(is);
 		size_t ldata = read<unsigned int>(is);
 		is.seekg(4, is.cur);
 		size_t lkey = read<unsigned short int>(is);
 		short cycle = read<short>(is);
 		is.seekg(8, is.cur);
 		std::string cname(read<unsigned char>(is), 0);
 		is.read(&cname[0], cname.size());
 		if (cname.size() == 4 && cname.substr(0, 3) == "TH1") {
 			KeyBuffer::ContentType type;
 			switch (cname[3]) {
 				case 'D':
 					type = KeyBuffer::ContentType::Double;
 					break;
 				case 'F':
 					type = KeyBuffer::ContentType::Float;
 					break;
 				case 'I':
 					type = KeyBuffer::ContentType::Int;
 					break;
 				case 'S':
 					type = KeyBuffer::ContentType::Short;
 					break;
 				case 'C':
 					type = KeyBuffer::ContentType::Byte;
 					break;
 				default:
 					type = KeyBuffer::ContentType::Invalid;
 					break;
 			}
 			if (type) {
 				std::string name(read<unsigned char>(is), 0);
 				is.read(&name[0], name.size());
 				std::string title(read<unsigned char>(is), 0);
 				is.read(&title[0], title.size());
 
 				auto it = histkeys.end();
 				// see root/io/io/src/TKey.cxx for reference
 				if (compression && ldata > 256) {
 #					ifdef HAVE_ZIP
 					// Default: compression level
 					// ZLIB: 100 + compression level
 					// LZ4:  400 + compression level
 					if (compression / 100 <= 1 || compression / 100 == 4) {
 						// see root/core/zip/src/RZip.cxx -> R__unzip
 						std::string lib(2, 0);
 						is.read(&lib[0], 2);
 						char method = is.get();
 						size_t chcdata = is.get();
 						chcdata |= (is.get() << 8);
 						chcdata |= (is.get() << 16);
 						size_t chdata = is.get();
 						chdata |= (is.get() << 8);
 						chdata |= (is.get() << 16);
 
 						if (chcdata == lcdata - lkey - 9 && chdata == ldata) {
 							if (lib == "ZL" && method == Z_DEFLATED) {
 								it = histkeys.emplace(name + ';' + std::to_string(cycle),
 								                      KeyBuffer{name, title, cycle, type, KeyBuffer::zlib,
 								                                pos + lkey + 9, chcdata, chdata, 0}
 								                     ).first;
 							} else if (lib == "L4" && method == LZ4_versionNumber() / (100 * 100)) {
 								it = histkeys.emplace(name + ';' + std::to_string(cycle),
 								                      KeyBuffer{name, title, cycle, type, KeyBuffer::lz4,
 								                                pos + lkey + 9 + 8, chcdata - 8, chdata, 0}
 								                     ).first;
 							}
 						}
 					}
 #					endif
 				} else {
 					it = histkeys.emplace(name + ';' + std::to_string(cycle),
 					                      KeyBuffer{name, title, cycle, type, KeyBuffer::none,
 					                                pos + lkey, ldata, ldata, 0}
 					                     ).first;
 				}
 				if (it != histkeys.end())
 					readNBins(it->second);
 			}
 		}
 		pos += (int)lcdata;
 	}
 }
 
 std::vector<std::string> ROOTHist::listHistograms() const {
 	std::vector<std::string> l;
-	for (auto& n : histkeys) {
+	for (auto& n : histkeys)
 		l.emplace_back(n.first);
-	}
+
 	return l;
 }
 
 std::vector<ROOTHist::BinPars> ROOTHist::readHistogram(const std::string& name, int cycle) {
 	auto it = histkeys.find(name + ';' + std::to_string(cycle));
 	if (it == histkeys.end())
 		return std::vector<ROOTHist::BinPars>();
 
 	std::string buffer = data(it->second);
 	if (!buffer.empty()) {
 		// The object structure can be retrieved from TFile::GetStreamerInfoList().
 		// Every ROOT object contains a version number which may include the byte count
 		// for the object. The latter is currently assumed to be present to skip unused
 		// objects. No checks are performed. The corresponding ROOT code is quite nested
 		// but the actual readout is straight forward.
 		// Files for reference:
 		// root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
 		// root/core/cont/src/TArrayD.cxx -> Streamer
 		// root/hist/hist/src/TH1.cxx -> Streamer
 		char *buf = &buffer[0];
 		size_t count;
 		Version(buf, count); // TH1(D/F/I/S/C)
 		char* dbuf = buf + 4;
 		Version(buf, count); // TH1
 		dbuf += count;
 		Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
 
 		std::vector<BinPars> r(read<int>(buf)); // fNcells
 		if (r.size() < 3)
 			return std::vector<BinPars>();
 
 		r.front().lowedge = -std::numeric_limits<double>::infinity();
 
 		// x-Axis
 		char* nbuf = buf + 4;
 		Version(buf, count); // TAxis
 		nbuf += count;
 		Skip(buf, 2); // skip TNamed, TAttAxis
 
 		int nbins = read<int>(buf);
 		double xmin = read<double>(buf);
 		double xmax = read<double>(buf);
 		const size_t nborders = read<int>(buf);
 
 		if (nborders == r.size() - 1) {
 			for (size_t i = 0; i < nborders; ++i) {
 				r[i + 1].lowedge = read<double>(buf);
 			}
 		} else {
 			buf += sizeof(double) * nbins;
 			const double scale = (xmax - xmin) / static_cast<double>(nbins);
 			for (size_t i = 0; i < r.size() - 1; ++i) {
 				r[i + 1].lowedge = static_cast<double>(i) * scale + xmin;
 			}
 		}
 		buf = nbuf;
 		Skip(buf, 2); // skip y-Axis and z-Axis;
 		buf += 68; // skip 2 shorts and 8 doubles
 		buf += read<int>(buf) * 8; // skip fContour array
 
 		if (static_cast<size_t>(read<int>(buf)) == r.size()) {
 			for (auto& b : r)
 				b.sumw2 = read<double>(buf); // always double
 		}
 
 		buf = dbuf; // skip to contents of TH1(D/F/I/S/C)
 
 		if (static_cast<size_t>(read<int>(buf)) == r.size()) {
 			switch (it->second.type) {
 				case KeyBuffer::ContentType::Double:
 					for (auto& b : r)
 						b.content = read<double>(buf);
 					break;
 				case KeyBuffer::ContentType::Float:
 					for (auto& b : r)
 						b.content = read<float>(buf);
 					break;
 				case KeyBuffer::ContentType::Int:
 					for (auto& b : r)
 						b.content = read<int>(buf);
 					break;
 				case KeyBuffer::ContentType::Short:
 					for (auto& b : r)
 						b.content = read<short>(buf);
 					break;
 				case KeyBuffer::ContentType::Byte:
 					for (auto& b : r)
 						b.content = read<char>(buf);
 					break;
 				case KeyBuffer::ContentType::Invalid: // never reached
 				default:
 					break;
 			}
 		}
 
 		return r;
 	} else
 		return std::vector<BinPars>();
 }
 
 void ROOTHist::readNBins(ROOTHist::KeyBuffer& kbuffer) {
 	std::string buffer = data(kbuffer);
 	if (!buffer.empty()) {
 		// The object structure can be retrieved from TFile::GetStreamerInfoList().
 		// Every ROOT object contains a version number which may include the byte count
 		// for the object. The latter is currently assumed to be present to skip unused
 		// objects. No checks are performed. The corresponding ROOT code is quite nested
 		// but the actual readout is straight forward.
 		// Files for reference:
 		// root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
 		// root/core/cont/src/TArrayD.cxx -> Streamer
 		// root/hist/hist/src/TH1.cxx -> Streamer
 		char *buf = &buffer[0];
 		size_t count;
 		Version(buf, count); // TH1(D/F/I/S/C)
 		char* dbuf = buf + 4;
 		Version(buf, count); // TH1
 		dbuf += count;
 		Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
 
 		kbuffer.nbins = read<int>(buf); // fNcells
 	}
 }
 
 std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer) const {
 	std::ifstream is(filename, std::ifstream::binary);
 	return data(buffer, is);
 }
 
 std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer, std::ifstream& is) const {
 	std::string data(buffer.count, 0);
 	is.seekg(buffer.start);
 	if (buffer.compression == KeyBuffer::none) {
 		is.read(&data[0], buffer.count);
 		return data;
 #ifdef HAVE_ZIP
 	} else if (buffer.compression == KeyBuffer::zlib) {
 		std::string cdata(buffer.compressed_count, 0);
 		is.read(&cdata[0], buffer.compressed_count);
 		size_t luncomp = buffer.count;
 		if (uncompress((Bytef *)data.data(), &luncomp, (Bytef *)cdata.data(), cdata.size()) == Z_OK && data.size() == luncomp)
 			return data;
 	} else {
 		std::string cdata(buffer.compressed_count, 0);
 		is.read(&cdata[0], buffer.compressed_count);
 		if (LZ4_decompress_safe(cdata.data(), const_cast<char*>(data.data()), buffer.compressed_count, buffer.count) == static_cast<int>(buffer.count))
 			return data;
 #endif
 	}
 
 	return std::string();
 }
diff --git a/src/backend/datasources/projects/OriginProjectParser.cpp b/src/backend/datasources/projects/OriginProjectParser.cpp
index 7f9313d79..45b7b3f6d 100644
--- a/src/backend/datasources/projects/OriginProjectParser.cpp
+++ b/src/backend/datasources/projects/OriginProjectParser.cpp
@@ -1,2155 +1,2155 @@
 /***************************************************************************
     File                 : OriginProjectParser.h
     Project              : LabPlot
     Description          : parser for Origin projects
     --------------------------------------------------------------------
     Copyright            : (C) 2017-2018 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2017-2018 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 "backend/datasources/projects/OriginProjectParser.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/core/Project.h"
 #include "backend/core/Workbook.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/note/Note.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlotLegend.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/plots/cartesian/XYEquationCurve.h"
 #include "backend/worksheet/TextLabel.h"
 
 #include <liborigin/OriginFile.h>
 
 #include <KLocalizedString>
 
 #include <QDir>
 #include <QDateTime>
 #include <QFontMetrics>
 
 /*!
 \class OriginProjectParser
 \brief parser for Origin projects.
 
 \ingroup datasources
 */
 
 OriginProjectParser::OriginProjectParser() : ProjectParser(), m_originFile(nullptr), m_importUnusedObjects(false) {
 	m_topLevelClasses << "Folder" << "Workbook" << "Spreadsheet" << "Matrix" << "Worksheet" << "Note";
 }
 
 bool OriginProjectParser::isOriginProject(const QString& fileName) {
 	//TODO add opju later when liborigin supports it
 	return fileName.endsWith(QLatin1String(".opj"), Qt::CaseInsensitive);
 }
 
 void OriginProjectParser::setImportUnusedObjects(bool importUnusedObjects) {
 	m_importUnusedObjects = importUnusedObjects;
 }
 
 bool OriginProjectParser::hasUnusedObjects() {
 	if (m_originFile)
 		delete m_originFile;
 	m_originFile = new OriginFile((const char*)m_projectFileName.toLocal8Bit());
 	if (!m_originFile->parse())
 		return false;
 
 	for (unsigned int i = 0; i < m_originFile->spreadCount(); i++) {
 		const Origin::SpreadSheet& spread = m_originFile->spread(i);
 		if (spread.objectID < 0)
 			return true;
 	}
 	for (unsigned int i = 0; i < m_originFile->excelCount(); i++) {
 		const Origin::Excel& excel = m_originFile->excel(i);
 		if (excel.objectID < 0)
 			return true;
 	}
 	for (unsigned int i = 0; i < m_originFile->matrixCount(); i++) {
 		const Origin::Matrix& originMatrix = m_originFile->matrix(i);
 		if (originMatrix.objectID < 0)
 			return true;
 	}
 
 	return false;
 }
 
 QString OriginProjectParser::supportedExtensions() {
 	//TODO add opju later when liborigin supports it
 	static const QString extensions = "*.opj *.OPJ";
 	return extensions;
 }
 
 unsigned int OriginProjectParser::findSpreadByName(const QString& name) {
 	for (unsigned int i = 0; i < m_originFile->spreadCount(); i++) {
 		const Origin::SpreadSheet& spread = m_originFile->spread(i);
 		if (spread.name == name.toStdString()) {
 			m_spreadNameList << name;
 			return i;
 		}
 	}
 	return 0;
 }
 unsigned int OriginProjectParser::findMatrixByName(const QString& name) {
 	for (unsigned int i = 0; i < m_originFile->matrixCount(); i++) {
 		const Origin::Matrix& originMatrix = m_originFile->matrix(i);
 		if (originMatrix.name == name.toStdString()) {
 			m_matrixNameList << name;
 			return i;
 		}
 	}
 	return 0;
 }
 unsigned int OriginProjectParser::findExcelByName(const QString& name) {
 	for (unsigned int i = 0; i < m_originFile->excelCount(); i++) {
 		const Origin::Excel& excel = m_originFile->excel(i);
 		if (excel.name == name.toStdString()) {
 			m_excelNameList << name;
 			return i;
 		}
 	}
 	return 0;
 }
 unsigned int OriginProjectParser::findGraphByName(const QString& name) {
 	for (unsigned int i = 0; i < m_originFile->graphCount(); i++) {
 		const Origin::Graph& graph = m_originFile->graph(i);
 		if (graph.name == name.toStdString()) {
 			m_graphNameList << name;
 			return i;
 		}
 	}
 	return 0;
 }
 unsigned int OriginProjectParser::findNoteByName(const QString& name) {
 	for (unsigned int i = 0; i < m_originFile->noteCount(); i++) {
 		const Origin::Note& originNote = m_originFile->note(i);
 		if (originNote.name == name.toStdString()) {
 			m_noteNameList << name;
 			return i;
 		}
 	}
 	return 0;
 }
 
 //##############################################################################
 //############## Deserialization from Origin's project tree ####################
 //##############################################################################
 bool OriginProjectParser::load(Project* project, bool preview) {
 	DEBUG("OriginProjectParser::load()");
 	//read and parse the m_originFile-file
 	if (m_originFile)
 		delete m_originFile;
 
 	m_originFile = new OriginFile((const char*)m_projectFileName.toLocal8Bit());
 	if (!m_originFile->parse())
 		return false;
 
 	//Origin project tree and the iterator pointing to the root node
 	const tree<Origin::ProjectNode>* projectTree = m_originFile->project();
 	tree<Origin::ProjectNode>::iterator projectIt = projectTree->begin(projectTree->begin());
 
 	m_spreadNameList.clear();
 	m_excelNameList.clear();
 	m_matrixNameList.clear();
 	m_graphNameList.clear();
 	m_noteNameList.clear();
 
 	//convert the project tree from liborigin's representation to LabPlot's project object
 	project->setIsLoading(true);
 	if (projectIt.node) { // only opj files from version >= 6.0 do have project tree
 		QString name(QString::fromLatin1(projectIt->name.c_str()));
 		project->setName(name);
 		project->setCreationTime(creationTime(projectIt));
 		loadFolder(project, projectIt, preview);
 	} else { // for lower versions put all windows on rootfolder
 		int pos = m_projectFileName.lastIndexOf(QDir::separator()) + 1;
 		project->setName((const char*)m_projectFileName.mid(pos).toLocal8Bit());
 	}
 	// imports all loose windows (like prior version 6 which has no project tree)
 	handleLooseWindows(project, preview);
 
 
 	//restore column pointers:
 	//1. extend the pathes to contain the parent structures first
 	//2. restore the pointers from the pathes
 	const QVector<Column*> columns = project->children<Column>(AbstractAspect::Recursive);
 	const QVector<Spreadsheet*> spreadsheets = project->children<Spreadsheet>(AbstractAspect::Recursive);
 	for (auto* curve : project->children<XYCurve>(AbstractAspect::Recursive)) {
 		curve->suppressRetransform(true);
 
 		//x-column
 		QString spreadsheetName = curve->xColumnPath().left(curve->xColumnPath().indexOf(QLatin1Char('/')));
 		for (const auto* spreadsheet : spreadsheets) {
 			if (spreadsheet->name() == spreadsheetName) {
 				const QString& newPath = spreadsheet->parentAspect()->path() + '/' + curve->xColumnPath();
 				curve->setXColumnPath(newPath);
 
 				for (auto* column : columns) {
 					if (!column)
 						continue;
 					if (column->path() == newPath) {
 						curve->setXColumn(column);
 						break;
 					}
 				}
 				break;
 			}
 		}
 
 		//x-column
 		spreadsheetName = curve->yColumnPath().left(curve->yColumnPath().indexOf(QLatin1Char('/')));
 		for (const auto* spreadsheet : spreadsheets) {
 			if (spreadsheet->name() == spreadsheetName) {
 				const QString& newPath = spreadsheet->parentAspect()->path() + '/' + curve->yColumnPath();
 				curve->setYColumnPath(newPath);
 
 				for (auto* column : columns) {
 					if (!column)
 						continue;
 					if (column->path() == newPath) {
 						curve->setYColumn(column);
 						break;
 					}
 				}
 				break;
 			}
 		}
 
 		//TODO: error columns
 
 
 		curve->suppressRetransform(false);
 	}
 
 	if (!preview) {
 		for (auto* plot : project->children<CartesianPlot>(AbstractAspect::Recursive)) {
 			plot->setIsLoading(false);
 			plot->retransform();
 		}
 	}
 
 	emit project->loaded();
 	project->setIsLoading(false);
 	return true;
 }
 
 bool OriginProjectParser::loadFolder(Folder* folder, tree<Origin::ProjectNode>::iterator baseIt, bool preview) {
 	DEBUG("OriginProjectParser::loadFolder()\n--------------------------------");
 	const tree<Origin::ProjectNode>* projectTree = m_originFile->project();
 
 	//load folder's children: logic for reading the selected objects only is similar to Folder::readChildAspectElement
 	for (tree<Origin::ProjectNode>::sibling_iterator it = projectTree->begin(baseIt); it != projectTree->end(baseIt); ++it) {
 		QString name(QString::fromLatin1(it->name.c_str())); //name of the current child
 		DEBUG("	* folder item name = " << name.toStdString());
 
 		//check whether we need to skip the loading of the current child
 		if (!folder->pathesToLoad().isEmpty()) {
 			//child's path is not available yet (child not added yet) -> construct the path manually
 			const QString childPath = folder->path() + '/' + name;
 
 			//skip the current child aspect it is not in the list of aspects to be loaded
 			if (folder->pathesToLoad().indexOf(childPath) == -1)
 				continue;
 		}
 
 		//load top-level children
 		AbstractAspect* aspect = nullptr;
 		switch (it->type) {
 		case Origin::ProjectNode::Folder: {
 			DEBUG("	top level folder");
 			Folder* f = new Folder(name);
 
 			if (!folder->pathesToLoad().isEmpty()) {
 				//a child folder to be read -> provide the list of aspects to be loaded to the child folder, too.
 				//since the child folder and all its children are not added yet (path() returns empty string),
 				//we need to remove the path of the current child folder from the full pathes provided in pathesToLoad.
 				//E.g. we want to import the path "Project/Folder/Spreadsheet" in the following project
 				// Project
 				//        \Spreadsheet
 				//        \Folder
 				//               \Spreadsheet
 				//
 				//Here, we remove the part "Project/Folder/" and proceed for this child folder with "Spreadsheet" only.
 				//With this the logic above where it is determined whether to import the child aspect or not works out.
 
 				//manually construct the path of the child folder to be read
 				const QString& curFolderPath = folder->path()  + '/' + name;
 
 				//remove the path of the current child folder
 				QStringList pathesToLoadNew;
 				for (const auto& path : folder->pathesToLoad()) {
 					if (path.startsWith(curFolderPath))
 						pathesToLoadNew << path.right(path.length() - curFolderPath.length());
 				}
 
 				f->setPathesToLoad(pathesToLoadNew);
 			}
 
 			loadFolder(f, it, preview);
 			aspect = f;
 			break;
 		}
 		case Origin::ProjectNode::SpreadSheet: {
 			DEBUG("	top level spreadsheet");
 			Spreadsheet* spreadsheet = new Spreadsheet(name);
 			loadSpreadsheet(spreadsheet, preview, name);
 			aspect = spreadsheet;
 			break;
 		}
 		case Origin::ProjectNode::Graph: {
 			DEBUG("	top level graph");
 			Worksheet* worksheet = new Worksheet(name);
 			worksheet->setIsLoading(true);
 			worksheet->setTheme("");
 			loadWorksheet(worksheet, preview);
 			aspect = worksheet;
 			break;
 		}
 		case Origin::ProjectNode::Matrix: {
 			DEBUG("	top level matrix");
 			const Origin::Matrix& originMatrix = m_originFile->matrix(findMatrixByName(name));
 			DEBUG("	matrix name = " << originMatrix.name);
 			DEBUG("	number of sheets = " << originMatrix.sheets.size());
 			if (originMatrix.sheets.size() == 1) {
 				// single sheet -> load into a matrix
 				Matrix* matrix = new Matrix(name);
 				loadMatrix(matrix, preview);
 				aspect = matrix;
 			} else {
 				// multiple sheets -> load into a workbook
 				Workbook* workbook = new Workbook(name);
 				loadMatrixWorkbook(workbook, preview);
 				aspect = workbook;
 			}
 			break;
 		}
 		case Origin::ProjectNode::Excel: {
 			DEBUG("	top level excel");
 			Workbook* workbook = new Workbook(name);
 			loadWorkbook(workbook, preview);
 			aspect = workbook;
 			break;
 		}
 		case Origin::ProjectNode::Note: {
 			DEBUG("top level note");
 			Note* note = new Note(name);
 			loadNote(note, preview);
 			aspect = note;
 			break;
 		}
 		case Origin::ProjectNode::Graph3D:
 		default:
 			//TODO: add UnsupportedAspect
 			break;
 		}
 
 		if (aspect) {
 			folder->addChildFast(aspect);
 			aspect->setCreationTime(creationTime(it));
 			aspect->setIsLoading(false);
 		}
 	}
 
 	// ResultsLog
 	QString resultsLog = QString::fromLatin1(m_originFile->resultsLogString().c_str());
 	if (resultsLog.length() > 0) {
 		DEBUG("Results log:\t\tyes");
 		Note* note = new Note("ResultsLog");
 
 		if (preview)
 			folder->addChildFast(note);
 		else {
 			//only import the log if it is in the list of aspects to be loaded
 			const QString childPath = folder->path() + '/' + note->name();
 			if (folder->pathesToLoad().indexOf(childPath) != -1) {
 				note->setText(resultsLog);
 				folder->addChildFast(note);
 			}
 		}
 	} else
 		DEBUG("Results log:\t\tno");
 
 	return folder;
 }
 
 void OriginProjectParser::handleLooseWindows(Folder* folder, bool preview) {
 	DEBUG("OriginProjectParser::handleLooseWindows()");
 	QDEBUG("pathes to load:" << folder->pathesToLoad());
 	m_spreadNameList.removeDuplicates();
 	m_excelNameList.removeDuplicates();
 	m_matrixNameList.removeDuplicates();
 	m_graphNameList.removeDuplicates();
 	m_noteNameList.removeDuplicates();
 	QDEBUG("	spreads =" << m_spreadNameList);
 	QDEBUG("	excels =" << m_excelNameList);
 	QDEBUG("	matrices =" << m_matrixNameList);
 	QDEBUG("	graphs =" << m_graphNameList);
 	QDEBUG("	notes =" << m_noteNameList);
 
 	DEBUG("Number of spreads loaded:\t" << m_spreadNameList.size() << ", in file: " << m_originFile->spreadCount());
 	DEBUG("Number of excels loaded:\t" << m_excelNameList.size() << ", in file: " << m_originFile->excelCount());
 	DEBUG("Number of matrices loaded:\t" << m_matrixNameList.size() << ", in file: " << m_originFile->matrixCount());
 	DEBUG("Number of graphs loaded:\t" << m_graphNameList.size() << ", in file: " << m_originFile->graphCount());
 	DEBUG("Number of notes loaded:\t\t" << m_noteNameList.size() << ", in file: " << m_originFile->noteCount());
 
 	// loop over all spreads to find loose ones
 	for (unsigned int i = 0; i < m_originFile->spreadCount(); i++) {
 		AbstractAspect* aspect = nullptr;
 		const Origin::SpreadSheet& spread = m_originFile->spread(i);
 		QString name = QString::fromStdString(spread.name);
 
 		DEBUG("	spread.objectId = " << spread.objectID);
 		// skip unused spreads if selected
 		if (spread.objectID < 0 && !m_importUnusedObjects) {
 			DEBUG("	Dropping unused loose spread: " << name.toStdString());
 			continue;
 		}
 
 		const QString childPath = folder->path() + '/' + name;
 		// we could also use spread.loose
 		if (!m_spreadNameList.contains(name) && (preview || (!preview && folder->pathesToLoad().indexOf(childPath) != -1))) {
 			DEBUG("	Adding loose spread: " << name.toStdString());
 
 			Spreadsheet* spreadsheet = new Spreadsheet(name);
 			loadSpreadsheet(spreadsheet, preview, name);
 			aspect = spreadsheet;
 		}
 		if (aspect) {
 			folder->addChildFast(aspect);
 			DEBUG("	creation time as reported by liborigin: " << spread.creationDate);
 			aspect->setCreationTime(QDateTime::fromTime_t(spread.creationDate));
 		}
 	}
 	// loop over all excels to find loose ones
 	for (unsigned int i = 0; i < m_originFile->excelCount(); i++) {
 		AbstractAspect* aspect = nullptr;
 		const Origin::Excel& excel = m_originFile->excel(i);
 		QString name = QString::fromStdString(excel.name);
 
 		DEBUG("	excel.objectId = " << excel.objectID);
 		// skip unused data sets if selected
 		if (excel.objectID < 0 && !m_importUnusedObjects) {
 			DEBUG("	Dropping unused loose excel: " << name.toStdString());
 			continue;
 		}
 
 		const QString childPath = folder->path() + '/' + name;
 		// we could also use excel.loose
 		if (!m_excelNameList.contains(name) && (preview || (!preview && folder->pathesToLoad().indexOf(childPath) != -1))) {
 			DEBUG("	Adding loose excel: " << name.toStdString());
 			DEBUG("	 containing number of sheets = " << excel.sheets.size());
 
 			Workbook* workbook = new Workbook(name);
 			loadWorkbook(workbook, preview);
 			aspect = workbook;
 		}
 		if (aspect) {
 			folder->addChildFast(aspect);
 			DEBUG("	creation time as reported by liborigin: " << excel.creationDate);
 			aspect->setCreationTime(QDateTime::fromTime_t(excel.creationDate));
 		}
 	}
 	// loop over all matrices to find loose ones
 	for (unsigned int i = 0; i < m_originFile->matrixCount(); i++) {
 		AbstractAspect* aspect = nullptr;
 		const Origin::Matrix& originMatrix = m_originFile->matrix(i);
 		QString name = QString::fromStdString(originMatrix.name);
 
 		DEBUG("	originMatrix.objectId = " << originMatrix.objectID);
 		// skip unused data sets if selected
 		if (originMatrix.objectID < 0 && !m_importUnusedObjects) {
 			DEBUG("	Dropping unused loose matrix: " << name.toStdString());
 			continue;
 		}
 
 		const QString childPath = folder->path() + '/' + name;
 		if (!m_matrixNameList.contains(name) && (preview || (!preview && folder->pathesToLoad().indexOf(childPath) != -1))) {
 			DEBUG("	Adding loose matrix: " << name.toStdString());
 			DEBUG("	containing number of sheets = " << originMatrix.sheets.size());
 			if (originMatrix.sheets.size() == 1) { // single sheet -> load into a matrix
 				Matrix* matrix = new Matrix(name);
 				loadMatrix(matrix, preview);
 				aspect = matrix;
 			} else { // multiple sheets -> load into a workbook
 				Workbook* workbook = new Workbook(name);
 				loadMatrixWorkbook(workbook, preview);
 				aspect = workbook;
 			}
 		}
 		if (aspect) {
 			folder->addChildFast(aspect);
 			aspect->setCreationTime(QDateTime::fromTime_t(originMatrix.creationDate));
 		}
 	}
 	// handle loose graphs (is this even possible?)
 	for (unsigned int i = 0; i < m_originFile->graphCount(); i++) {
 		AbstractAspect* aspect = nullptr;
 		const Origin::Graph& graph = m_originFile->graph(i);
 		QString name = QString::fromStdString(graph.name);
 
 		DEBUG("	graph.objectId = " << graph.objectID);
 		// skip unused graph if selected
 		if (graph.objectID < 0 && !m_importUnusedObjects) {
 			DEBUG("	Dropping unused loose graph: " << name.toStdString());
 			continue;
 		}
 
 		const QString childPath = folder->path() + '/' + name;
 		if (!m_graphNameList.contains(name) && (preview || (!preview && folder->pathesToLoad().indexOf(childPath) != -1))) {
 			DEBUG("	Adding loose graph: " << name.toStdString());
 			Worksheet* worksheet = new Worksheet(name);
 			loadWorksheet(worksheet, preview);
 			aspect = worksheet;
 		}
 		if (aspect) {
 			folder->addChildFast(aspect);
 			aspect->setCreationTime(QDateTime::fromTime_t(graph.creationDate));
 		}
 	}
 	// handle loose notes (is this even possible?)
 	for (unsigned int i = 0; i < m_originFile->noteCount(); i++) {
 		AbstractAspect* aspect = nullptr;
 		const Origin::Note& originNote = m_originFile->note(i);
 		QString name = QString::fromStdString(originNote.name);
 
 		DEBUG("	originNote.objectId = " << originNote.objectID);
 		// skip unused notes if selected
 		if (originNote.objectID < 0 && !m_importUnusedObjects) {
 			DEBUG("	Dropping unused loose note: " << name.toStdString());
 			continue;
 		}
 
 		const QString childPath = folder->path() + '/' + name;
 		if (!m_noteNameList.contains(name) && (preview || (!preview && folder->pathesToLoad().indexOf(childPath) != -1))) {
 			DEBUG("	Adding loose note: " << name.toStdString());
 			Note* note = new Note(name);
 			loadNote(note, preview);
 			aspect = note;
 		}
 		if (aspect) {
 			folder->addChildFast(aspect);
 			aspect->setCreationTime(QDateTime::fromTime_t(originNote.creationDate));
 		}
 	}
 }
 
 bool OriginProjectParser::loadWorkbook(Workbook* workbook, bool preview) {
 	DEBUG("loadWorkbook()");
 	//load workbook sheets
 	const Origin::Excel& excel = m_originFile->excel(findExcelByName(workbook->name()));
 	DEBUG(" excel name = " << excel.name);
 	DEBUG(" number of sheets = " << excel.sheets.size());
 	for (unsigned int s = 0; s < excel.sheets.size(); ++s) {
 		Spreadsheet* spreadsheet = new Spreadsheet(QString::fromLatin1(excel.sheets[s].name.c_str()));
 		loadSpreadsheet(spreadsheet, preview, workbook->name(), s);
 		workbook->addChildFast(spreadsheet);
 	}
 
 	return true;
 }
 
 // load spreadsheet from spread (sheetIndex == -1) or from excel (only sheet sheetIndex)
 bool OriginProjectParser::loadSpreadsheet(Spreadsheet* spreadsheet, bool preview, const QString& name, int sheetIndex) {
 	DEBUG("loadSpreadsheet() sheetIndex = " << sheetIndex);
 
 	//load spreadsheet data
 	Origin::SpreadSheet spread;
 	Origin::Excel excel;
 	if (sheetIndex == -1)	// spread
 		spread = m_originFile->spread(findSpreadByName(name));
 	else {
 		excel = m_originFile->excel(findExcelByName(name));
 		spread = excel.sheets[sheetIndex];
 	}
 
 	const size_t cols = spread.columns.size();
 	int rows = 0;
 	for (size_t j = 0; j < cols; ++j)
 		rows = std::max((int)spread.columns[j].data.size(), rows);
 	// alternative: int rows = excel.maxRows;
 	DEBUG("loadSpreadsheet() cols/maxRows = " << cols << "/" << rows);
 
 	//TODO QLocale locale = mw->locale();
 
 	spreadsheet->setRowCount(rows);
 	spreadsheet->setColumnCount((int)cols);
 	if (sheetIndex == -1)
 		spreadsheet->setComment(QString::fromLatin1(spread.label.c_str()));
 	else
 		spreadsheet->setComment(QString::fromLatin1(excel.label.c_str()));
 
 	//in Origin column width is measured in characters, we need to convert to pixels
 	//TODO: determine the font used in Origin in order to get the same column width as in Origin
 	QFont font;
 	QFontMetrics fm(font);
 	const int scaling_factor = fm.maxWidth();
 
 	for (size_t j = 0; j < cols; ++j) {
 		Origin::SpreadColumn column = spread.columns[j];
 		Column* col = spreadsheet->column((int)j);
 
 		QString name(column.name.c_str());
 		col->setName(name.replace(QRegExp(".*_"),""));
 
 		if (preview)
 			continue;
 
 		//TODO: we don't support any formulas for cells yet.
 // 		if (column.command.size() > 0)
 // 			col->setFormula(Interval<int>(0, rows), QString(column.command.c_str()));
 
 		col->setComment(QString::fromLatin1(column.comment.c_str()));
 		col->setWidth((int)column.width * scaling_factor);
 
 		//plot designation
 		switch (column.type) {
 		case Origin::SpreadColumn::X:
 			col->setPlotDesignation(AbstractColumn::X);
 			break;
 		case Origin::SpreadColumn::Y:
 			col->setPlotDesignation(AbstractColumn::Y);
 			break;
 		case Origin::SpreadColumn::Z:
 			col->setPlotDesignation(AbstractColumn::Z);
 			break;
 		case Origin::SpreadColumn::XErr:
 			col->setPlotDesignation(AbstractColumn::XError);
 			break;
 		case Origin::SpreadColumn::YErr:
 			col->setPlotDesignation(AbstractColumn::YError);
 			break;
 		case Origin::SpreadColumn::Label:
 		case Origin::SpreadColumn::NONE:
 		default:
 			col->setPlotDesignation(AbstractColumn::NoDesignation);
 		}
 
 		QString format;
 		switch(column.valueType) {
 		case Origin::Numeric: {
 			for (unsigned int i = column.beginRow; i < column.endRow; ++i) {
 				const double value = column.data.at(i).as_double();
 				if (value != _ONAN)
 					col->setValueAt(i, value);
 			}
 
 			loadColumnNumericFormat(column, col);
 			break;
 		}
 		case Origin::TextNumeric: {
 			//A TextNumeric column can contain numeric and string values, there is no equivalent column mode in LabPlot.
 			// -> Set the column mode as 'Numeric' or 'Text' depending on the type of first non-empty element in column.
 			for (unsigned int i = column.beginRow; i < column.endRow; ++i) {
 				const Origin::variant value(column.data.at(i));
 				if (value.type() == Origin::Variant::V_DOUBLE) {
 					if (value.as_double() != _ONAN)
 						break;
 				} else {
 					if (value.as_string() != nullptr) {
 						col->setColumnMode(AbstractColumn::Text);
 						break;
 					}
 				}
 			}
 
 			if (col->columnMode() == AbstractColumn::Numeric) {
 				for (unsigned int i = column.beginRow; i < column.endRow; ++i) {
 					const double value = column.data.at(i).as_double();
 					if (column.data.at(i).type() == Origin::Variant::V_DOUBLE && value != _ONAN)
 						col->setValueAt(i, value);
 				}
 				loadColumnNumericFormat(column, col);
 			} else {
 				for (unsigned int i = column.beginRow; i < column.endRow; ++i) {
 					const Origin::variant value(column.data.at(i));
 					if (value.type() == Origin::Variant::V_STRING) {
 						if (value.as_string() != nullptr)
 							col->setTextAt(i, value.as_string());
 					} else {
 						if (value.as_double() != _ONAN)
 							col->setTextAt(i, QString::number(value.as_double()));
 					}
 				}
 			}
 			break;
 		}
 		case Origin::Text:
 			col->setColumnMode(AbstractColumn::Text);
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setTextAt(i, column.data[i].as_string());
 			break;
 		case Origin::Time: {
 			switch (column.valueTypeSpecification + 128) {
 			case Origin::TIME_HH_MM:
 				format="hh:mm";
 				break;
 			case Origin::TIME_HH:
 				format="hh";
 				break;
 			case Origin::TIME_HH_MM_SS:
 				format="hh:mm:ss";
 				break;
 			case Origin::TIME_HH_MM_SS_ZZ:
 				format="hh:mm:ss.zzz";
 				break;
 			case Origin::TIME_HH_AP:
 				format="hh ap";
 				break;
 			case Origin::TIME_HH_MM_AP:
 				format="hh:mm ap";
 				break;
 			case Origin::TIME_MM_SS:
 				format="mm:ss";
 				break;
 			case Origin::TIME_MM_SS_ZZ:
 				format="mm:ss.zzz";
 				break;
 			case Origin::TIME_HHMM:
 				format="hhmm";
 				break;
 			case Origin::TIME_HHMMSS:
 				format="hhmmss";
 				break;
 			case Origin::TIME_HH_MM_SS_ZZZ:
 				format="hh:mm:ss.zzz";
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::DateTime);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Date: {
 			switch (column.valueTypeSpecification) {
 			case Origin::DATE_DD_MM_YYYY:
 				format="dd/MM/yyyy";
 				break;
 			case Origin::DATE_DD_MM_YYYY_HH_MM:
 				format="dd/MM/yyyy HH:mm";
 				break;
 			case Origin::DATE_DD_MM_YYYY_HH_MM_SS:
 				format="dd/MM/yyyy HH:mm:ss";
 				break;
 			case Origin::DATE_DDMMYYYY:
 			case Origin::DATE_DDMMYYYY_HH_MM:
 			case Origin::DATE_DDMMYYYY_HH_MM_SS:
 				format="dd.MM.yyyy";
 					break;
 			case Origin::DATE_MMM_D:
 				format="MMM d";
 				break;
 			case Origin::DATE_M_D:
 				format="M/d";
 				break;
 			case Origin::DATE_D:
 				format='d';
 				break;
 			case Origin::DATE_DDD:
 			case Origin::DATE_DAY_LETTER:
 				format="ddd";
 				break;
 			case Origin::DATE_YYYY:
 				format="yyyy";
 				break;
 			case Origin::DATE_YY:
 				format="yy";
 				break;
 			case Origin::DATE_YYMMDD:
 			case Origin::DATE_YYMMDD_HH_MM:
 			case Origin::DATE_YYMMDD_HH_MM_SS:
 			case Origin::DATE_YYMMDD_HHMM:
 			case Origin::DATE_YYMMDD_HHMMSS:
 				format="yyMMdd";
 				break;
 			case Origin::DATE_MMM:
 			case Origin::DATE_MONTH_LETTER:
 				format="MMM";
 				break;
 			case Origin::DATE_M_D_YYYY:
 				format="M-d-yyyy";
 				break;
 			default:
 				format="dd.MM.yyyy";
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::DateTime);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Month: {
 			switch (column.valueTypeSpecification) {
 			case Origin::MONTH_MMM:
 				format = "MMM";
 				break;
 			case Origin::MONTH_MMMM:
 				format = "MMMM";
 				break;
 			case Origin::MONTH_LETTER:
 				format = 'M';
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::Month);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::Day: {
 			switch (column.valueTypeSpecification) {
 			case Origin::DAY_DDD:
 				format = "ddd";
 				break;
 			case Origin::DAY_DDDD:
 				format = "dddd";
 				break;
 			case Origin::DAY_LETTER:
 				format = 'd';
 				break;
 			}
 
 			for (int i = 0; i < min((int)column.data.size(), rows); ++i)
 				col->setValueAt(i, column.data[i].as_double());
 			col->setColumnMode(AbstractColumn::Day);
 
 			DateTime2StringFilter *filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			break;
 		}
 		case Origin::ColumnHeading:
 		case Origin::TickIndexedDataset:
 		case Origin::Categorical:
 			break;
 		}
 	}
 
 	//TODO: "hidden" not supporrted yet
 //	if (spread.hidden || spread.loose)
 //		mw->hideWindow(spreadsheet);
 
 	return true;
 }
 
 void OriginProjectParser::loadColumnNumericFormat(const Origin::SpreadColumn& originColumn, Column* column) const {
 	if (originColumn.numericDisplayType != 0) {
 		int fi = 0;
 		switch (originColumn.valueTypeSpecification) {
 		case Origin::Decimal:
 			fi = 1;
 			break;
 		case Origin::Scientific:
 			fi = 2;
 			break;
 		case Origin::Engineering:
 		case Origin::DecimalWithMarks:
 			break;
 		}
 
 		Double2StringFilter* filter = static_cast<Double2StringFilter*>(column->outputFilter());
 		filter->setNumericFormat(fi);
 		filter->setNumDigits(originColumn.decimalPlaces);
 	}
 }
 
 bool OriginProjectParser::loadMatrixWorkbook(Workbook* workbook, bool preview) {
 	DEBUG("loadMatrixWorkbook()");
 	//load matrix workbook sheets
 	const Origin::Matrix& originMatrix = m_originFile->matrix(findMatrixByName(workbook->name()));
 	for (size_t s = 0; s < originMatrix.sheets.size(); ++s) {
 		Matrix* matrix = new Matrix(QString::fromLatin1(originMatrix.sheets[s].name.c_str()));
 		loadMatrix(matrix, preview, s, workbook->name());
 		workbook->addChildFast(matrix);
 	}
 
 	return true;
 }
 
 bool OriginProjectParser::loadMatrix(Matrix* matrix, bool preview, size_t sheetIndex, const QString& mwbName) {
 	DEBUG("loadMatrix()");
 	//import matrix data
 	const Origin::Matrix& originMatrix = m_originFile->matrix(findMatrixByName(mwbName));
 
 	if (preview)
 		return true;
 
 
 	//in Origin column width is measured in characters, we need to convert to pixels
 	//TODO: determine the font used in Origin in order to get the same column width as in Origin
 	QFont font;
 	QFontMetrics fm(font);
 	const int scaling_factor = fm.maxWidth();
 
 	const Origin::MatrixSheet& layer = originMatrix.sheets[sheetIndex];
 	const int colCount = layer.columnCount;
 	const int rowCount = layer.rowCount;
 
 	matrix->setRowCount(rowCount);
 	matrix->setColumnCount(colCount);
 	matrix->setFormula(layer.command.c_str());
 
 	//TODO: how to handle different widths for different columns?
 	for (int j = 0; j < colCount; j++)
 		matrix->setColumnWidth(j, layer.width * scaling_factor);
 
 	//TODO: check column major vs. row major to improve the performance here
 	for (int i = 0; i < rowCount; i++) {
 		for (int j = 0; j < colCount; j++)
 			matrix->setCell(i, j, layer.data[j + i*colCount]);
 	}
 
 	char format = 'g';
 	//TODO: prec not support by Matrix
 	//int prec = 6;
 	switch (layer.valueTypeSpecification) {
 	case 0: //Decimal 1000
 		format='f';
 	//	prec = layer.decimalPlaces;
 		break;
 	case 1: //Scientific
 		format='e';
 	//	prec = layer.decimalPlaces;
 		break;
 	case 2: //Engineering
 	case 3: //Decimal 1,000
 		format='g';
 	//	prec = layer.significantDigits;
 		break;
 	}
 
 	matrix->setNumericFormat(format);
 
 	return true;
 }
 
 bool OriginProjectParser::loadWorksheet(Worksheet* worksheet, bool preview) {
 	DEBUG("OriginProjectParser::loadWorksheet()");
 
 	//load worksheet data
 	const Origin::Graph& graph = m_originFile->graph(findGraphByName(worksheet->name()));
 	DEBUG("	graph name = " << graph.name);
 	worksheet->setComment(graph.label.c_str());
 
 	//TODO: width, height, view mode (print view, page view, window view, draft view)
 	//Origin allows to freely resize the window and ajusts the size of the plot (layer) automatically
 	//by keeping a certain width-to-height ratio. It's not clear what the actual size of the plot/layer is and how to handle this.
 	//For now we simply create a new wokrsheet here with it's default size and make it using the whole view size.
 	//Later we can decide to use one of the following properties:
 	// 1) Window.frameRect gives Rect-corner coordinates (in pixels) of the Window object
 	// 2) GraphLayer.clientRect gives Rect-corner coordinates (pixels) of the Layer inside the (printer?) page.
 	// 3) Graph.width, Graph.height give the (printer?) page size in pixels.
 // 	const QRectF size(0, 0,
 // 					  Worksheet::convertToSceneUnits(graph.width/600., Worksheet::Inch),
 // 					  Worksheet::convertToSceneUnits(graph.height/600., Worksheet::Inch));
 // 	worksheet->setPageRect(size);
 	worksheet->setUseViewSize(true);
 
 	QMap<TextLabel*, QSizeF> textLabelPositions;
 
 	// worksheet background color
 	const Origin::ColorGradientDirection bckgColorGradient = graph.windowBackgroundColorGradient;
 	const Origin::Color bckgBaseColor = graph.windowBackgroundColorBase;
 	const Origin::Color bckgEndColor =  graph.windowBackgroundColorEnd;
 	worksheet->setBackgroundColorStyle(backgroundColorStyle(bckgColorGradient));
 	switch (bckgColorGradient) {
 		case Origin::ColorGradientDirection::NoGradient:
 		case Origin::ColorGradientDirection::TopLeft:
 		case Origin::ColorGradientDirection::Left:
 		case Origin::ColorGradientDirection::BottomLeft:
 		case Origin::ColorGradientDirection::Top:
 			worksheet->setBackgroundFirstColor(color(bckgEndColor));
 			worksheet->setBackgroundSecondColor(color(bckgBaseColor));
 			break;
 		case Origin::ColorGradientDirection::Center:
 			break;
 		case Origin::ColorGradientDirection::Bottom:
 		case Origin::ColorGradientDirection::TopRight:
 		case Origin::ColorGradientDirection::Right:
 		case Origin::ColorGradientDirection::BottomRight:
 			worksheet->setBackgroundFirstColor(color(bckgBaseColor));
 			worksheet->setBackgroundSecondColor(color(bckgEndColor));
 	}
 
 	//TODO: do we need changes on the worksheet layout?
 
 	//add plots
 	int index = 1;
-	for (const auto& layer: graph.layers) {
+	for (const auto& layer : graph.layers) {
 		if (!layer.is3D()) {
 			CartesianPlot* plot = new CartesianPlot(i18n("Plot%1", QString::number(index)));
 			worksheet->addChildFast(plot);
 			plot->setIsLoading(true);
 			//TODO: width, height
 
 			//background color
 			const Origin::Color& regColor = layer.backgroundColor;
 			if (regColor.type == Origin::Color::None)
 				plot->plotArea()->setBackgroundOpacity(0);
 			else
 				plot->plotArea()->setBackgroundFirstColor(color(regColor));
 
 			//border
 			if (layer.borderType == Origin::BorderType::None)
 				plot->plotArea()->setBorderPen(QPen(Qt::NoPen));
 			else
 				plot->plotArea()->setBorderPen(QPen(Qt::SolidLine));
 
 			//ranges
 			plot->setAutoScaleX(false);
 			plot->setAutoScaleY(false);
 			const Origin::GraphAxis& originXAxis = layer.xAxis;
 			const Origin::GraphAxis& originYAxis = layer.yAxis;
 			plot->setXMin(originXAxis.min);
 			plot->setXMax(originXAxis.max);
 			plot->setYMin(originYAxis.min);
 			plot->setYMax(originYAxis.max);
 
 			//scales
 			switch(originXAxis.scale) {
 			case Origin::GraphAxis::Linear:
 				plot->setXScale(CartesianPlot::ScaleLinear);
 				break;
 			case Origin::GraphAxis::Log10:
 				plot->setXScale(CartesianPlot::ScaleLog10);
 				break;
 			case Origin::GraphAxis::Ln:
 				plot->setXScale(CartesianPlot::ScaleLn);
 				break;
 			case Origin::GraphAxis::Log2:
 				plot->setXScale(CartesianPlot::ScaleLog2);
 				break;
 			case Origin::GraphAxis::Probability:
 			case Origin::GraphAxis::Probit:
 			case Origin::GraphAxis::Reciprocal:
 			case Origin::GraphAxis::OffsetReciprocal:
 			case Origin::GraphAxis::Logit:
 				//TODO:
 				plot->setXScale(CartesianPlot::ScaleLinear);
 				break;
 			}
 
 			switch(originYAxis.scale) {
 			case Origin::GraphAxis::Linear:
 				plot->setYScale(CartesianPlot::ScaleLinear);
 				break;
 			case Origin::GraphAxis::Log10:
 				plot->setYScale(CartesianPlot::ScaleLog10);
 				break;
 			case Origin::GraphAxis::Ln:
 				plot->setYScale(CartesianPlot::ScaleLn);
 				break;
 			case Origin::GraphAxis::Log2:
 				plot->setYScale(CartesianPlot::ScaleLog2);
 				break;
 			case Origin::GraphAxis::Probability:
 			case Origin::GraphAxis::Probit:
 			case Origin::GraphAxis::Reciprocal:
 			case Origin::GraphAxis::OffsetReciprocal:
 			case Origin::GraphAxis::Logit:
 				//TODO:
 				plot->setYScale(CartesianPlot::ScaleLinear);
 				break;
 			}
 
 			//axes
 			//x bottom
 			if (layer.curves.size()) {
 				Origin::GraphCurve originCurve = layer.curves[0];
 				QString xColumnName = QString::fromLatin1(originCurve.xColumnName.c_str());
 				//TODO: "Partikelgrö"
 				DEBUG("	xColumnName = " << xColumnName.toStdString());
 				QDEBUG("	UTF8 xColumnName = " << xColumnName.toUtf8());
 				QString yColumnName = QString::fromLatin1(originCurve.yColumnName.c_str());
 
 				if (!originXAxis.formatAxis[0].hidden) {
 					Axis* axis = new Axis("x", Axis::AxisHorizontal);
 					axis->setSuppressRetransform(true);
 					axis->setPosition(Axis::AxisBottom);
 					plot->addChildFast(axis);
 					loadAxis(originXAxis, axis, 0, xColumnName);
 					axis->setSuppressRetransform(false);
 				}
 
 				//x top
 				if (!originXAxis.formatAxis[1].hidden) {
 					Axis* axis = new Axis("x top", Axis::AxisHorizontal);
 					axis->setPosition(Axis::AxisTop);
 					axis->setSuppressRetransform(true);
 					plot->addChildFast(axis);
 					loadAxis(originXAxis, axis, 1, xColumnName);
 					axis->setSuppressRetransform(false);
 				}
 
 				//y left
 				if (!originYAxis.formatAxis[0].hidden) {
 					Axis* axis = new Axis("y", Axis::AxisVertical);
 					axis->setSuppressRetransform(true);
 					axis->setPosition(Axis::AxisLeft);
 					plot->addChildFast(axis);
 					loadAxis(originYAxis, axis, 0, yColumnName);
 					axis->setSuppressRetransform(false);
 				}
 
 				//y right
 				if (!originYAxis.formatAxis[1].hidden) {
 					Axis* axis = new Axis("y right", Axis::AxisVertical);
 					axis->setSuppressRetransform(true);
 					axis->setPosition(Axis::AxisRight);
 					plot->addChildFast(axis);
 					loadAxis(originYAxis, axis, 1, yColumnName);
 					axis->setSuppressRetransform(false);
 				}
 			} else {
 				//TODO: ?
 			}
 
 			//range breaks
 			//TODO
 
 			//add legend if available
 			const Origin::TextBox& originLegend = layer.legend;
 			const QString& legendText = QString::fromLatin1(originLegend.text.c_str());
 			DEBUG(" legend text = " << legendText.toStdString());
 			if (!originLegend.text.empty()) {
 				CartesianPlotLegend* legend = new CartesianPlotLegend(plot, i18n("legend"));
 
 				//Origin's legend uses "\l(...)" or "\L(...)" string to format the legend symbol
 				// and "%(...) to format the legend text for each curve
 				//s. a. https://www.originlab.com/doc/Origin-Help/Legend-ManualControl
 				//the text before these formatting tags, if available, is interpreted as the legend title
 				QString legendTitle;
 
 				//search for the first occurrence of the legend symbol substring
 				int index = legendText.indexOf(QLatin1String("\\l("), 0, Qt::CaseInsensitive);
 				if (index != -1)
 					legendTitle = legendText.left(index);
 				else {
 					//check legend text
 					index = legendText.indexOf(QLatin1String("%("));
 					if (index != -1)
 						legendTitle = legendText.left(index);
 				}
 
 				legendTitle = legendTitle.trimmed();
 				if (!legendTitle.isEmpty())
 					legendTitle = parseOriginText(legendTitle);
 
 				DEBUG(" legend title = " << legendTitle.toStdString());
 				legend->title()->setText(legendTitle);
 
 				//TODO: text color
 				//const Origin::Color& originColor = originLegend.color;
 
 				//position
 				//TODO: for the first release with OPJ support we put the legend to the bottom left corner,
 				//in the next release we'll evaluate originLegend.clientRect giving the position inside of the whole page in Origin.
 				//In Origin the legend can be placed outside of the plot which is not possible in LabPlot.
 				//To achieve this we'll need to increase padding area in the plot and to place the legend outside of the plot area.
 				CartesianPlotLegend::PositionWrapper position;
 				position.horizontalPosition = CartesianPlotLegend::hPositionRight;
 				position.verticalPosition = CartesianPlotLegend::vPositionBottom;
 				legend->setPosition(position);
 
 				//rotation
 				legend->setRotationAngle(originLegend.rotation);
 
 				//border line
 				if (originLegend.borderType == Origin::BorderType::None)
 					legend->setBorderPen(QPen(Qt::NoPen));
 				else
 					legend->setBorderPen(QPen(Qt::SolidLine));
 
 				//background color, determine it with the help of the border type
 				if (originLegend.borderType == Origin::BorderType::DarkMarble)
 					legend->setBackgroundFirstColor(Qt::darkGray);
 				else if (originLegend.borderType == Origin::BorderType::BlackOut)
 					legend->setBackgroundFirstColor(Qt::black);
 				else
 					legend->setBackgroundFirstColor(Qt::white);
 
 				plot->addLegend(legend);
 			}
 
 			//texts
-			for (const auto& s: layer.texts) {
+			for (const auto& s : layer.texts) {
 				DEBUG("EXTRA TEXT = " << s.text.c_str());
 				TextLabel* label = new TextLabel("text label");
 				label->setText(parseOriginText(QString::fromLatin1(s.text.c_str())));
 				plot->addChild(label);
 				label->setParentGraphicsItem(plot->graphicsItem());
 
 				//position
 				//determine the relative position inside of the layer rect
 				const float horRatio = (float)(s.clientRect.left-layer.clientRect.left)/(layer.clientRect.right-layer.clientRect.left);
 				const float vertRatio = (float)(s.clientRect.top-layer.clientRect.top)/(layer.clientRect.bottom-layer.clientRect.top);
 				textLabelPositions[label] = QSizeF(horRatio, vertRatio);
 				DEBUG("horizontal/vertical ratio = " << horRatio << ", " << vertRatio);
 
 				//rotation
 				label->setRotationAngle(s.rotation);
 
 				//TODO:
 // 				Color color;
 // 				unsigned short fontSize;
 // 				int tab;
 // 				BorderType borderType;
 // 				Attach attach;
 			}
 
 			//curves
 			int curveIndex = 1;
-			for (const auto& originCurve: layer.curves) {
+			for (const auto& originCurve : layer.curves) {
 
 				QString data(originCurve.dataName.c_str());
 				switch(data[0].toLatin1()) {
 				case 'T':
 				case 'E': {
 					if (originCurve.type == Origin::GraphCurve::Line || originCurve.type == Origin::GraphCurve::Scatter || originCurve.type == Origin::GraphCurve::LineSymbol
 						|| originCurve.type == Origin::GraphCurve::ErrorBar || originCurve.type == Origin::GraphCurve::XErrorBar) {
 
 						// parse and use legend text
 						// find substring between %c{curveIndex} and %c{curveIndex+1}
 						int pos1 = legendText.indexOf(QString("\\c{%1}").arg(curveIndex)) + 5;
 						int pos2 = legendText.indexOf(QString("\\c{%1}").arg(curveIndex+1));
 						QString curveText = legendText.mid(pos1, pos2 - pos1);
 						// replace %(1), %(2), etc. with curve name
 						curveText.replace(QString("%(%1)").arg(curveIndex), QString::fromLatin1(originCurve.yColumnName.c_str()));
 						curveText = curveText.trimmed();
 						DEBUG(" curve " << curveIndex << " text = " << curveText.toStdString());
 
 						//XYCurve* xyCurve = new XYCurve(i18n("Curve%1", QString::number(curveIndex)));
 						//TODO: curve (legend) does not support HTML text yet.
 						//XYCurve* xyCurve = new XYCurve(curveText);
 						XYCurve* curve = new XYCurve(QString::fromLatin1(originCurve.yColumnName.c_str()));
 						const QString& tableName = data.right(data.length() - 2);
 						curve->setXColumnPath(tableName + '/' + originCurve.xColumnName.c_str());
 						curve->setYColumnPath(tableName + '/' + originCurve.yColumnName.c_str());
 
 						curve->suppressRetransform(true);
 						if (!preview)
 							loadCurve(originCurve, curve);
 						plot->addChildFast(curve);
 						curve->suppressRetransform(false);
 					} else if (originCurve.type == Origin::GraphCurve::Column) {
 						//vertical bars
 
 					} else if (originCurve.type == Origin::GraphCurve::Bar) {
 						//horizontal bars
 
 					} else if (originCurve.type == Origin::GraphCurve::Histogram) {
 
 					}
 				}
 				break;
 				case 'F': {
 					Origin::Function function;
 					const vector<Origin::Function>::difference_type funcIndex = m_originFile->functionIndex(data.right(data.length()-2).toStdString().c_str());
 					if (funcIndex < 0) {
 						++curveIndex;
 						continue;
 					}
 
 					function = m_originFile->function(funcIndex);
 
 					XYEquationCurve* xyEqCurve = new XYEquationCurve(function.name.c_str());
 					XYEquationCurve::EquationData eqData;
 
 					eqData.count = function.totalPoints;
 					eqData.expression1 = QString(function.formula.c_str());
 
 					if(function.type == Origin::Function::Polar) {
 						eqData.type = XYEquationCurve::Polar;
 
 						//replace 'x' by 'phi'
 						eqData.expression1 = eqData.expression1.replace('x', "phi");
 
 						//convert from degrees to radians
 						eqData.min = QString::number(function.begin/180) + QLatin1String("*pi");
 						eqData.max = QString::number(function.end/180) + QLatin1String("*pi");
 					} else {
 						eqData.expression1 = QString(function.formula.c_str());
 						eqData.min = QString::number(function.begin);
 						eqData.max = QString::number(function.end);
 					}
 
 					xyEqCurve->suppressRetransform(true);
 					xyEqCurve->setEquationData(eqData);
 					if (!preview)
 						loadCurve(originCurve, xyEqCurve);
 					plot->addChildFast(xyEqCurve);
 					xyEqCurve->suppressRetransform(false);
 				}
 				}
 
 				++curveIndex;
 			}
 		} else {
 			//no support for 3D plots yet
 			//TODO: add an "UnsupportedAspect" here
 		}
 
 		++index;
 	}
 
 	if (!preview) {
 		worksheet->updateLayout();
 
 		//worksheet and plots got their sizes,
 		//-> position all text labels inside the plots correctly by converting
 		//the relative positions determined above to the absolute values
 		QMap<TextLabel*, QSizeF>::const_iterator it = textLabelPositions.constBegin();
 		while (it != textLabelPositions.constEnd()) {
 			TextLabel* label = it.key();
 			const QSizeF& ratios = it.value();
 			const CartesianPlot* plot = static_cast<const CartesianPlot*>(label->parentAspect());
 
 			TextLabel::PositionWrapper position = label->position();
 			position.point.setX(plot->dataRect().width()*(ratios.width()-0.5));
 			position.point.setY(plot->dataRect().height()*(ratios.height()-0.5));
 			label->setPosition(position);
 
 			++it;
 		}
 	}
 
 	return true;
 }
 
 /*
  * sets the axis properties (format and ticks) as defined in \c originAxis in \c axis,
  * \c index being 0 or 1 for "top" and "bottom" or "left" and "right" for horizontal or vertical axes, respectively.
  */
 void OriginProjectParser::loadAxis(const Origin::GraphAxis& originAxis, Axis* axis, int index, const QString& axisTitle) const {
 // 	int axisPosition;
 //		possible values:
 //			0: Axis is at default position
 //			1: Axis is at (axisPositionValue)% from standard position
 //			2: Axis is at (axisPositionValue) position of orthogonal axis
 // 		double axisPositionValue;
 
 // 		bool zeroLine;
 // 		bool oppositeLine;
 
 	//ranges
 	axis->setStart(originAxis.min);
 	axis->setEnd(originAxis.max);
 
 	//ticks
 	axis->setMajorTicksType(Axis::TicksIncrement);
 	axis->setMajorTicksIncrement(originAxis.step);
 	axis->setMinorTicksType(Axis::TicksTotalNumber);
 	axis->setMinorTicksNumber(originAxis.minorTicks);
 
 	//scale
 	switch(originAxis.scale) {
 	case Origin::GraphAxis::Linear:
 		axis->setScale(Axis::ScaleLinear);
 		break;
 	case Origin::GraphAxis::Log10:
 		axis->setScale(Axis::ScaleLog10);
 		break;
 	case Origin::GraphAxis::Ln:
 		axis->setScale(Axis::ScaleLn);
 		break;
 	case Origin::GraphAxis::Log2:
 		axis->setScale(Axis::ScaleLog2);
 		break;
 	case Origin::GraphAxis::Probability:
 	case Origin::GraphAxis::Probit:
 	case Origin::GraphAxis::Reciprocal:
 	case Origin::GraphAxis::OffsetReciprocal:
 	case Origin::GraphAxis::Logit:
 		//TODO:
 		axis->setScale(Axis::ScaleLinear);
 		break;
 	}
 
 	//major grid
 	const Origin::GraphGrid& majorGrid = originAxis.majorGrid;
 	QPen gridPen = axis->majorGridPen();
 	Qt::PenStyle penStyle(Qt::NoPen);
 	if (!majorGrid.hidden) {
 		switch (majorGrid.style) {
 		case Origin::GraphCurve::Solid:
 			penStyle = Qt::SolidLine;
 			break;
 		case Origin::GraphCurve::Dash:
 		case Origin::GraphCurve::ShortDash:
 			penStyle = Qt::DashLine;
 			break;
 		case Origin::GraphCurve::Dot:
 		case Origin::GraphCurve::ShortDot:
 			penStyle = Qt::DotLine;
 			break;
 		case Origin::GraphCurve::DashDot:
 		case Origin::GraphCurve::ShortDashDot:
 			penStyle = Qt::DashDotLine;
 			break;
 		case Origin::GraphCurve::DashDotDot:
 			penStyle = Qt::DashDotDotLine;
 			break;
 		}
 	}
 	gridPen.setStyle(penStyle);
 
 	Origin::Color gridColor;
 	gridColor.type = Origin::Color::ColorType::Regular;
 	gridColor.regular = majorGrid.color;
 	gridPen.setColor(OriginProjectParser::color(gridColor));
 	gridPen.setWidthF(Worksheet::convertToSceneUnits(majorGrid.width, Worksheet::Point));
 	axis->setMajorGridPen(gridPen);
 
 	//minor grid
 	const Origin::GraphGrid& minorGrid = originAxis.minorGrid;
 	gridPen = axis->minorGridPen();
 	penStyle = Qt::NoPen;
 	if (!minorGrid.hidden) {
 		switch (minorGrid.style) {
 		case Origin::GraphCurve::Solid:
 			penStyle = Qt::SolidLine;
 			break;
 		case Origin::GraphCurve::Dash:
 		case Origin::GraphCurve::ShortDash:
 			penStyle = Qt::DashLine;
 			break;
 		case Origin::GraphCurve::Dot:
 		case Origin::GraphCurve::ShortDot:
 			penStyle = Qt::DotLine;
 			break;
 		case Origin::GraphCurve::DashDot:
 		case Origin::GraphCurve::ShortDashDot:
 			penStyle = Qt::DashDotLine;
 			break;
 		case Origin::GraphCurve::DashDotDot:
 			penStyle = Qt::DashDotDotLine;
 			break;
 		}
 	}
 	gridPen.setStyle(penStyle);
 
 	gridColor.regular = minorGrid.color;
 	gridPen.setColor(OriginProjectParser::color(gridColor));
 	gridPen.setWidthF(Worksheet::convertToSceneUnits(minorGrid.width, Worksheet::Point));
 	axis->setMinorGridPen(gridPen);
 
 	//process Origin::GraphAxisFormat
 	const Origin::GraphAxisFormat& axisFormat = originAxis.formatAxis[index];
 
 	QPen pen;
 	Origin::Color color;
 	color.type = Origin::Color::ColorType::Regular;
 	color.regular = axisFormat.color;
 	pen.setColor(OriginProjectParser::color(color));
 	pen.setWidthF(Worksheet::convertToSceneUnits(axisFormat.thickness, Worksheet::Point));
 	axis->setLinePen(pen);
 
 	axis->setMajorTicksLength( Worksheet::convertToSceneUnits(axisFormat.majorTickLength, Worksheet::Point) );
 	axis->setMajorTicksDirection( (Axis::TicksFlags) axisFormat.majorTicksType);
 	axis->setMajorTicksPen(pen);
 	axis->setMinorTicksLength( axis->majorTicksLength()/2); // minorTicksLength is half of majorTicksLength
 	axis->setMinorTicksDirection( (Axis::TicksFlags) axisFormat.minorTicksType);
 	axis->setMinorTicksPen(pen);
 
 	QString titleText = parseOriginText(QString::fromLatin1(axisFormat.label.text.c_str()));
 	DEBUG("	axis title text = " << titleText.toStdString());
 	//TODO: parseOriginText() returns html formatted string. What is axisFormat.color used for?
 	//TODO: use axisFormat.fontSize to override the global font size for the hmtl string?
 	//TODO: convert special character here too
 	DEBUG("	curve name = " << axisTitle.toStdString());
 	titleText.replace("%(?X)", axisTitle);
 	titleText.replace("%(?Y)", axisTitle);
 	DEBUG(" axis title = " << titleText.toStdString());
 	axis->title()->setText(titleText);
 	axis->title()->setRotationAngle(axisFormat.label.rotation);
 
 	axis->setLabelsPrefix(axisFormat.prefix.c_str());
 	axis->setLabelsSuffix(axisFormat.suffix.c_str());
 	//TODO: handle string factor member in GraphAxisFormat
 
 	//process Origin::GraphAxisTick
 	const Origin::GraphAxisTick& tickAxis = originAxis.tickAxis[index];
 	if (tickAxis.showMajorLabels) {
 		color.type = Origin::Color::ColorType::Regular;
 		color.regular = tickAxis.color;
 		axis->setLabelsColor(OriginProjectParser::color(color));
 		//TODO: how to set labels position (top vs. bottom)?
 	} else {
 		axis->setLabelsPosition(Axis::LabelsPosition::NoLabels);
 	}
 
 	//TODO: handle ValueType valueType member in GraphAxisTick
 	//TODO: handle int valueTypeSpecification in GraphAxisTick
 
 	//precision
 	if (tickAxis.decimalPlaces == -1)
 		axis->setLabelsAutoPrecision(true);
 	else {
 		axis->setLabelsPrecision(tickAxis.decimalPlaces);
 		axis->setLabelsAutoPrecision(false);
 	}
 
 	QFont font;
 	//TODO: font family?
 	font.setPixelSize( Worksheet::convertToSceneUnits(tickAxis.fontSize, Worksheet::Point) );
 	font.setBold(tickAxis.fontBold);
 	axis->setLabelsFont(font);
 	//TODO: handle string dataName member in GraphAxisTick
 	//TODO: handle string columnName member in GraphAxisTick
 	axis->setLabelsRotationAngle(tickAxis.rotation);
 }
 
 void OriginProjectParser::loadCurve(const Origin::GraphCurve& originCurve, XYCurve* curve) const {
 	//line properties
 	QPen pen = curve->linePen();
 	Qt::PenStyle penStyle(Qt::NoPen);
 	if (originCurve.type == Origin::GraphCurve::Line || originCurve.type == Origin::GraphCurve::LineSymbol) {
 		switch(originCurve.lineConnect) {
 		case Origin::GraphCurve::NoLine:
 			curve->setLineType(XYCurve::NoLine);
 			break;
 		case Origin::GraphCurve::Straight:
 			curve->setLineType(XYCurve::Line);
 			break;
 		case Origin::GraphCurve::TwoPointSegment:
 			curve->setLineType(XYCurve::Segments2);
 			break;
 		case Origin::GraphCurve::ThreePointSegment:
 			curve->setLineType(XYCurve::Segments3);
 			break;
 		case Origin::GraphCurve::BSpline:
 		case Origin::GraphCurve::Bezier:
 		case Origin::GraphCurve::Spline:
 			curve->setLineType(XYCurve::SplineCubicNatural);
 			break;
 		case Origin::GraphCurve::StepHorizontal:
 			curve->setLineType(XYCurve::StartHorizontal);
 			break;
 		case Origin::GraphCurve::StepVertical:
 			curve->setLineType(XYCurve::StartVertical);
 			break;
 		case Origin::GraphCurve::StepHCenter:
 			curve->setLineType(XYCurve::MidpointHorizontal);
 			break;
 		case Origin::GraphCurve::StepVCenter:
 			curve->setLineType(XYCurve::MidpointVertical);
 			break;
 		}
 
 		switch (originCurve.lineStyle) {
 		case Origin::GraphCurve::Solid:
 			penStyle = Qt::SolidLine;
 			break;
 		case Origin::GraphCurve::Dash:
 		case Origin::GraphCurve::ShortDash:
 			penStyle = Qt::DashLine;
 			break;
 		case Origin::GraphCurve::Dot:
 		case Origin::GraphCurve::ShortDot:
 			penStyle = Qt::DotLine;
 			break;
 		case Origin::GraphCurve::DashDot:
 		case Origin::GraphCurve::ShortDashDot:
 			penStyle = Qt::DashDotLine;
 			break;
 		case Origin::GraphCurve::DashDotDot:
 			penStyle = Qt::DashDotDotLine;
 			break;
 		}
 
 		pen.setStyle(penStyle);
 		pen.setWidthF( Worksheet::convertToSceneUnits(originCurve.lineWidth, Worksheet::Point) );
 		pen.setColor(color(originCurve.lineColor));
 		curve->setLineOpacity(1 - originCurve.lineTransparency/255);
 
 		//TODO: handle unsigned char boxWidth of Origin::GraphCurve
 	}
 	pen.setStyle(penStyle);
 	curve->setLinePen(pen);
 
 
 	//symbol properties
 	if (originCurve.type == Origin::GraphCurve::Scatter || originCurve.type == Origin::GraphCurve::LineSymbol) {
 		//try to map the different symbols, mapping is not exact
 		curve->setSymbolsRotationAngle(0);
 		switch(originCurve.symbolShape) {
 		case 0: //NoSymbol
 			curve->setSymbolsStyle(Symbol::NoSymbols);
 			break;
 		case 1: //Rect
 			curve->setSymbolsStyle(Symbol::Square);
 			break;
 		case 2: //Ellipse
 		case 20://Sphere
 			curve->setSymbolsStyle(Symbol::Circle);
 			break;
 		case 3: //UTriangle
 			curve->setSymbolsStyle(Symbol::EquilateralTriangle);
 			break;
 		case 4: //DTriangle
 			curve->setSymbolsStyle(Symbol::EquilateralTriangle);
 			break;
 		case 5: //Diamond
 			curve->setSymbolsStyle(Symbol::Diamond);
 			break;
 		case 6: //Cross +
 			curve->setSymbolsStyle(Symbol::Cross);
 			break;
 		case 7: //Cross x
 			curve->setSymbolsStyle(Symbol::Cross);
 			break;
 		case 8: //Snow
 			curve->setSymbolsStyle(Symbol::Star4);
 			break;
 		case 9: //Horizontal -
 			curve->setSymbolsStyle(Symbol::Line);
 			curve->setSymbolsRotationAngle(90);
 			break;
 		case 10: //Vertical |
 			curve->setSymbolsStyle(Symbol::Line);
 			break;
 		case 15: //LTriangle
 			curve->setSymbolsStyle(Symbol::EquilateralTriangle);
 			break;
 		case 16: //RTriangle
 			curve->setSymbolsStyle(Symbol::EquilateralTriangle);
 			break;
 		case 17: //Hexagon
 		case 19: //Pentagon
 			curve->setSymbolsStyle(Symbol::Square);
 			break;
 		case 18: //Star
 			curve->setSymbolsStyle(Symbol::Star5);
 			break;
 		default:
 			curve->setSymbolsStyle(Symbol::NoSymbols);
 		}
 
 		//symbol size
 		curve->setSymbolsSize(Worksheet::convertToSceneUnits(originCurve.symbolSize, Worksheet::Point));
 
 		//symbol fill color
 		QBrush brush = curve->symbolsBrush();
 		if (originCurve.symbolFillColor.type == Origin::Color::ColorType::Automatic) {
 			//"automatic" color -> the color of the line, if available, has to be used, black otherwise
 			if (curve->lineType() != XYCurve::NoLine)
 				brush.setColor(curve->linePen().color());
 			else
 				brush.setColor(Qt::black);
 		} else
 			brush.setColor(color(originCurve.symbolFillColor));
 
 		curve->setSymbolsBrush(brush);
 
 		//symbol border/edge color and width
 		QPen pen = curve->symbolsPen();
 		if (originCurve.symbolColor.type == Origin::Color::ColorType::Automatic) {
 			//"automatic" color -> the color of the line, if available, has to be used, black otherwise
 			if (curve->lineType() != XYCurve::NoLine)
 				pen.setColor(curve->linePen().color());
 			else
 				pen.setColor(Qt::black);
 		} else
 			pen.setColor(color(originCurve.symbolColor));
 
 		//border width (edge thickness in Origin) is given by percentage of the symbol radius
 		pen.setWidthF(originCurve.symbolThickness/100.*curve->symbolsSize()/2.);
 
 		curve->setSymbolsPen(pen);
 
 		//handle unsigned char pointOffset member
 		//handle bool connectSymbols member
 	} else {
 		curve->setSymbolsStyle(Symbol::NoSymbols);
 	}
 
 	//filling properties
 	if(originCurve.fillArea) {
 		//TODO: handle unsigned char fillAreaType;
 		//with 'fillAreaType'=0x10 the area between the curve and the x-axis is filled
 		//with 'fillAreaType'=0x14 the area included inside the curve is filled. First and last curve points are joined by a line to close the otherwise open area.
 		//with 'fillAreaType'=0x12 the area excluded outside the curve is filled. The inverse of fillAreaType=0x14 is filled.
 		//At the moment we only support the first type, so set it to XYCurve::FillingBelow
 		curve->setFillingPosition(XYCurve::FillingBelow);
 
 		if (originCurve.fillAreaPattern == 0) {
 			curve->setFillingType(PlotArea::Color);
 		} else {
 			curve->setFillingType(PlotArea::Pattern);
 
 			//map different patterns in originCurve.fillAreaPattern (has the values of Origin::FillPattern) to Qt::BrushStyle;
 			switch(originCurve.fillAreaPattern) {
 			case 0:
 				curve->setFillingBrushStyle(Qt::NoBrush);
 				break;
 			case 1:
 			case 2:
 			case 3:
 				curve->setFillingBrushStyle(Qt::BDiagPattern);
 				break;
 			case 4:
 			case 5:
 			case 6:
 				curve->setFillingBrushStyle(Qt::FDiagPattern);
 				break;
 			case 7:
 			case 8:
 			case 9:
 				curve->setFillingBrushStyle(Qt::DiagCrossPattern);
 				break;
 			case 10:
 			case 11:
 			case 12:
 				curve->setFillingBrushStyle(Qt::HorPattern);
 				break;
 			case 13:
 			case 14:
 			case 15:
 				curve->setFillingBrushStyle(Qt::VerPattern);
 				break;
 			case 16:
 			case 17:
 			case 18:
 				curve->setFillingBrushStyle(Qt::CrossPattern);
 				break;
 			}
 		}
 
 		curve->setFillingFirstColor(color(originCurve.fillAreaColor));
 		curve->setFillingOpacity(1 - originCurve.fillAreaTransparency/255);
 
 		//Color fillAreaPatternColor - color for the pattern lines, not supported
 		//double fillAreaPatternWidth - width of the pattern lines, not supported
 		//bool fillAreaWithLineTransparency - transparency of the pattern lines independent of the area transparency, not supported
 
 		//TODO:
 		//unsigned char fillAreaPatternBorderStyle;
 		//Color fillAreaPatternBorderColor;
 		//double fillAreaPatternBorderWidth;
 		//The Border properties are used only in "Column/Bar" (histogram) plots. Those properties are:
 		//fillAreaPatternBorderStyle   for the line style (use enum Origin::LineStyle here)
 		//fillAreaPatternBorderColor   for the line color
 		//fillAreaPatternBorderWidth   for the line width
 	} else
 		curve->setFillingPosition(XYCurve::NoFilling);
 }
 
 bool OriginProjectParser::loadNote(Note* note, bool preview) {
 	DEBUG("OriginProjectParser::loadNote()");
 	//load note data
 	const Origin::Note& originNote = m_originFile->note(findNoteByName(note->name()));
 
 	if (preview)
 		return true;
 
 	note->setComment(originNote.label.c_str());
 	note->setNote(QString::fromLatin1(originNote.text.c_str()));
 
 	return true;
 }
 
 //##############################################################################
 //########################### Helper functions  ################################
 //##############################################################################
 QDateTime OriginProjectParser::creationTime(tree<Origin::ProjectNode>::iterator it) const {
 	//this logic seems to be correct only for the first node (project node). For other nodes the current time is returned.
 	char time_str[21];
 	strftime(time_str, sizeof(time_str), "%F %T", gmtime(&(*it).creationDate));
 	return QDateTime::fromString(QString(time_str), Qt::ISODate);
 }
 
 QString OriginProjectParser::parseOriginText(const QString &str) const {
 	DEBUG("parseOriginText()");
 	QStringList lines = str.split('\n');
 	QString text = "";
 	for (int i = 0; i < lines.size(); ++i) {
 		if (i > 0)
 			text.append("<br>");
 		text.append(parseOriginTags(lines[i]));
 	}
 
 	DEBUG(" PARSED TEXT = " << text.toStdString());
 
 	return text;
 }
 
 QColor OriginProjectParser::color(Origin::Color color) const {
 	switch (color.type) {
 		case Origin::Color::ColorType::Regular:
 			switch (color.regular) {
 				case Origin::Color::Black:
 					return QColor{Qt::black};
 				case Origin::Color::Red:
 					return QColor{Qt::red};
 				case Origin::Color::Green:
 					return QColor{Qt::green};
 				case Origin::Color::Blue:
 					return QColor{Qt::blue};
 				case Origin::Color::Cyan:
 					return QColor{Qt::cyan};
 				case Origin::Color::Magenta:
 					return QColor{Qt::magenta};
 				case Origin::Color::Yellow:
 					return QColor{Qt::yellow};
 				case Origin::Color::DarkYellow:
 					return QColor{Qt::darkYellow};
 				case Origin::Color::Navy:
 					return QColor{0, 0, 128};
 				case Origin::Color::Purple:
 					return QColor{128, 0, 128};
 				case Origin::Color::Wine:
 					return QColor{128, 0, 0};
 				case Origin::Color::Olive:
 					return QColor{0, 128, 0};
 				case Origin::Color::DarkCyan:
 					return QColor{Qt::darkCyan};
 				case Origin::Color::Royal:
 					return QColor{0, 0, 160};
 				case Origin::Color::Orange:
 					return QColor{255, 128, 0};
 				case Origin::Color::Violet:
 					return QColor{128, 0, 255};
 				case Origin::Color::Pink:
 					return QColor{255, 0, 128};
 				case Origin::Color::White:
 					return QColor{Qt::white};
 				case Origin::Color::LightGray:
 					return QColor{Qt::lightGray};
 				case Origin::Color::Gray:
 					return QColor{Qt::gray};
 				case Origin::Color::LTYellow:
 					return QColor{255, 0, 128};
 				case Origin::Color::LTCyan:
 					return QColor{128, 255, 255};
 				case Origin::Color::LTMagenta:
 					return QColor{255, 128, 255};
 				case Origin::Color::DarkGray:
 					return QColor{Qt::darkGray};
 				case Origin::Color::SpecialV7Axis:
 					return QColor{Qt::black};
 			}
 			break;
 		case Origin::Color::ColorType::Custom:
 			return QColor{color.custom[0], color.custom[1], color.custom[2]};
 		case Origin::Color::ColorType::None:
 		case Origin::Color::ColorType::Automatic:
 		case Origin::Color::ColorType::Increment:
 		case Origin::Color::ColorType::Indexing:
 		case Origin::Color::ColorType::RGB:
 		case Origin::Color::ColorType::Mapping:
 			break;
 	}
 
 	return QColor(Qt::white);
 }
 
 PlotArea::BackgroundColorStyle OriginProjectParser::backgroundColorStyle(Origin::ColorGradientDirection colorGradient) const {
 	switch (colorGradient) {
 		case Origin::ColorGradientDirection::NoGradient:
 			return PlotArea::BackgroundColorStyle::SingleColor;
 		case Origin::ColorGradientDirection::TopLeft:
 			return PlotArea::BackgroundColorStyle::TopLeftDiagonalLinearGradient;
 		case Origin::ColorGradientDirection::Left:
 			return PlotArea::BackgroundColorStyle::HorizontalLinearGradient;
 		case Origin::ColorGradientDirection::BottomLeft:
 			return PlotArea::BackgroundColorStyle::BottomLeftDiagonalLinearGradient;
 		case Origin::ColorGradientDirection::Top:
 			return PlotArea::BackgroundColorStyle::VerticalLinearGradient;
 		case Origin::ColorGradientDirection::Center:
 			return PlotArea::BackgroundColorStyle::RadialGradient;
 		case Origin::ColorGradientDirection::Bottom:
 			return PlotArea::BackgroundColorStyle::VerticalLinearGradient;
 		case Origin::ColorGradientDirection::TopRight:
 			return PlotArea::BackgroundColorStyle::BottomLeftDiagonalLinearGradient;
 		case Origin::ColorGradientDirection::Right:
 			return PlotArea::BackgroundColorStyle::HorizontalLinearGradient;
 		case Origin::ColorGradientDirection::BottomRight:
 			return PlotArea::BackgroundColorStyle::TopLeftDiagonalLinearGradient;
 	}
 
 	return PlotArea::BackgroundColorStyle::SingleColor;
 }
 
 QString strreverse(const QString &str) {	//QString reversing
 	QByteArray ba = str.toLocal8Bit();
 	std::reverse(ba.begin(), ba.end());
 
 	return QString(ba);
 }
 
 QList<QPair<QString, QString>> OriginProjectParser::charReplacementList() const {
 	QList<QPair<QString, QString>> replacements;
 
 	// TODO: probably missed some. Is there any generic method?
 	replacements << qMakePair(QString("ä"), QString("&auml;"));
 	replacements << qMakePair(QString("ö"), QString("&ouml;"));
 	replacements << qMakePair(QString("ü"), QString("&uuml;"));
 	replacements << qMakePair(QString("Ä"), QString("&Auml;"));
 	replacements << qMakePair(QString("Ö"), QString("&Ouml;"));
 	replacements << qMakePair(QString("Ü"), QString("&Uuml;"));
 	replacements << qMakePair(QString("ß"), QString("&szlig;"));
 	replacements << qMakePair(QString("€"), QString("&euro;"));
 	replacements << qMakePair(QString("£"), QString("&pound;"));
 	replacements << qMakePair(QString("¥"), QString("&yen;"));
 	replacements << qMakePair(QString("¤"), QString("&curren;")); // krazy:exclude=spelling
 	replacements << qMakePair(QString("¦"), QString("&brvbar;"));
 	replacements << qMakePair(QString("§"), QString("&sect;"));
 	replacements << qMakePair(QString("µ"), QString("&micro;"));
 	replacements << qMakePair(QString("¹"), QString("&sup1;"));
 	replacements << qMakePair(QString("²"), QString("&sup2;"));
 	replacements << qMakePair(QString("³"), QString("&sup3;"));
 	replacements << qMakePair(QString("¶"), QString("&para;"));
 	replacements << qMakePair(QString("ø"), QString("&oslash;"));
 	replacements << qMakePair(QString("æ"), QString("&aelig;"));
 	replacements << qMakePair(QString("ð"), QString("&eth;"));
 	replacements << qMakePair(QString("ħ"), QString("&hbar;"));
 	replacements << qMakePair(QString("ĸ"), QString("&kappa;"));
 	replacements << qMakePair(QString("¢"), QString("&cent;"));
 	replacements << qMakePair(QString("¼"), QString("&frac14;"));
 	replacements << qMakePair(QString("½"), QString("&frac12;"));
 	replacements << qMakePair(QString("¾"), QString("&frac34;"));
 	replacements << qMakePair(QString("¬"), QString("&not;"));
 	replacements << qMakePair(QString("©"), QString("&copy;"));
 	replacements << qMakePair(QString("®"), QString("&reg;"));
 	replacements << qMakePair(QString("ª"), QString("&ordf;"));
 	replacements << qMakePair(QString("º"), QString("&ordm;"));
 	replacements << qMakePair(QString("±"), QString("&plusmn;"));
 	replacements << qMakePair(QString("¿"), QString("&iquest;"));
 	replacements << qMakePair(QString("×"), QString("&times;"));
 	replacements << qMakePair(QString("°"), QString("&deg;"));
 	replacements << qMakePair(QString("«"), QString("&laquo;"));
 	replacements << qMakePair(QString("»"), QString("&raquo;"));
 	replacements << qMakePair(QString("¯"), QString("&macr;"));
 	replacements << qMakePair(QString("¸"), QString("&cedil;"));
 	replacements << qMakePair(QString("À"), QString("&Agrave;"));
 	replacements << qMakePair(QString("Á"), QString("&Aacute;"));
 	replacements << qMakePair(QString("Â"), QString("&Acirc;"));
 	replacements << qMakePair(QString("Ã"), QString("&Atilde;"));
 	replacements << qMakePair(QString("Å"), QString("&Aring;"));
 	replacements << qMakePair(QString("Æ"), QString("&AElig;"));
 	replacements << qMakePair(QString("Ç"), QString("&Ccedil;"));
 	replacements << qMakePair(QString("È"), QString("&Egrave;"));
 	replacements << qMakePair(QString("É"), QString("&Eacute;"));
 	replacements << qMakePair(QString("Ê"), QString("&Ecirc;"));
 	replacements << qMakePair(QString("Ë"), QString("&Euml;"));
 	replacements << qMakePair(QString("Ì"), QString("&Igrave;"));
 	replacements << qMakePair(QString("Í"), QString("&Iacute;"));
 	replacements << qMakePair(QString("Î"), QString("&Icirc;"));
 	replacements << qMakePair(QString("Ï"), QString("&Iuml;"));
 	replacements << qMakePair(QString("Ð"), QString("&ETH;"));
 	replacements << qMakePair(QString("Ñ"), QString("&Ntilde;"));
 	replacements << qMakePair(QString("Ò"), QString("&Ograve;"));
 	replacements << qMakePair(QString("Ó"), QString("&Oacute;"));
 	replacements << qMakePair(QString("Ô"), QString("&Ocirc;"));
 	replacements << qMakePair(QString("Õ"), QString("&Otilde;"));
 	replacements << qMakePair(QString("Ù"), QString("&Ugrave;"));
 	replacements << qMakePair(QString("Ú"), QString("&Uacute;"));
 	replacements << qMakePair(QString("Û"), QString("&Ucirc;"));
 	replacements << qMakePair(QString("Ý"), QString("&Yacute;"));
 	replacements << qMakePair(QString("Þ"), QString("&THORN;"));
 	replacements << qMakePair(QString("à"), QString("&agrave;"));
 	replacements << qMakePair(QString("á"), QString("&aacute;"));
 	replacements << qMakePair(QString("â"), QString("&acirc;"));
 	replacements << qMakePair(QString("ã"), QString("&atilde;"));
 	replacements << qMakePair(QString("å"), QString("&aring;"));
 	replacements << qMakePair(QString("ç"), QString("&ccedil;"));
 	replacements << qMakePair(QString("è"), QString("&egrave;"));
 	replacements << qMakePair(QString("é"), QString("&eacute;"));
 	replacements << qMakePair(QString("ê"), QString("&ecirc;"));
 	replacements << qMakePair(QString("ë"), QString("&euml;"));
 	replacements << qMakePair(QString("ì"), QString("&igrave;"));
 	replacements << qMakePair(QString("í"), QString("&iacute;"));
 	replacements << qMakePair(QString("î"), QString("&icirc;"));
 	replacements << qMakePair(QString("ï"), QString("&iuml;"));
 	replacements << qMakePair(QString("ñ"), QString("&ntilde;"));
 	replacements << qMakePair(QString("ò"), QString("&ograve;"));
 	replacements << qMakePair(QString("ó"), QString("&oacute;"));
 	replacements << qMakePair(QString("ô"), QString("&ocirc;"));
 	replacements << qMakePair(QString("õ"), QString("&otilde;"));
 	replacements << qMakePair(QString("÷"), QString("&divide;"));
 	replacements << qMakePair(QString("ù"), QString("&ugrave;"));
 	replacements << qMakePair(QString("ú"), QString("&uacute;"));
 	replacements << qMakePair(QString("û"), QString("&ucirc;"));
 	replacements << qMakePair(QString("ý"), QString("&yacute;"));
 	replacements << qMakePair(QString("þ"), QString("&thorn;"));
 	replacements << qMakePair(QString("ÿ"), QString("&yuml;"));
 	replacements << qMakePair(QString("Œ"), QString("&#338;"));
 	replacements << qMakePair(QString("œ"), QString("&#339;"));
 	replacements << qMakePair(QString("Š"), QString("&#352;"));
 	replacements << qMakePair(QString("š"), QString("&#353;"));
 	replacements << qMakePair(QString("Ÿ"), QString("&#376;"));
 	replacements << qMakePair(QString("†"), QString("&#8224;"));
 	replacements << qMakePair(QString("‡"), QString("&#8225;"));
 	replacements << qMakePair(QString("…"), QString("&#8230;"));
 	replacements << qMakePair(QString("‰"), QString("&#8240;"));
 	replacements << qMakePair(QString("™"), QString("&#8482;"));
 
 	return replacements;
 }
 
 QString OriginProjectParser::replaceSpecialChars(QString text) const {
 	QString t = text;
-        for (auto const &r : charReplacementList())
+        for (const auto& r : charReplacementList())
                 t.replace(r.first, r.second);
 	return t;
 }
 
 // taken from SciDAVis
 QString OriginProjectParser::parseOriginTags(const QString &str) const {
 	DEBUG("parseOriginTags()");
 	DEBUG("	string: " << str.toStdString());
 	QDEBUG("	UTF8 string: " << str.toUtf8());
 	QString line = str;
 
 	//replace \l(...) and %(...) tags
 	QRegExp rxline("\\\\\\s*l\\s*\\(\\s*\\d+\\s*\\)");
 // 	QRegExp rxcol("\\%\\(\\d+\\)");
 	int pos = rxline.indexIn(line);
 	while (pos > -1) {
 		QString value = rxline.cap(0);
 		int len = value.length();
 		value.replace(QRegExp(" "),"");
 		value = "\\c{" + value.mid(3, value.length()-4) + '}';
 		line.replace(pos, len, value);
 		pos = rxline.indexIn(line);
 	}
 
 	// replace umlauts etc.
 	line = replaceSpecialChars(line);
 
 	// replace tabs	(not really supported)
 	line.replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
 
 	//Lookbehind conditions are not supported - so need to reverse string
 	QRegExp rx("\\)[^\\)\\(]*\\((?!\\s*[buig\\+\\-]\\s*\\\\)");
 	QRegExp rxfont("\\)[^\\)\\(]*\\((?![^\\:]*\\:f\\s*\\\\)");
 	QString linerev = strreverse(line);
 	QString lBracket = strreverse("&lbracket;");
 	QString rBracket = strreverse("&rbracket;");
 	QString ltagBracket = strreverse("&ltagbracket;");
 	QString rtagBracket = strreverse("&rtagbracket;");
 	int pos1 = rx.indexIn(linerev);
 	int pos2 = rxfont.indexIn(linerev);
 
 	while (pos1 > -1 || pos2 > -1) {
 		if (pos1 == pos2) {
 			QString value = rx.cap(0);
 			int len = value.length();
 			value = rBracket + value.mid(1, len-2) + lBracket;
 			linerev.replace(pos1, len, value);
 		}
 		else if ((pos1 > pos2 && pos2 != -1) || pos1 == -1) {
 			QString value = rxfont.cap(0);
 			int len = value.length();
 			value = rtagBracket + value.mid(1, len-2) + ltagBracket;
 			linerev.replace(pos2, len, value);
 		}
 		else if ((pos2 > pos1 && pos1 != -1) || pos2 == -1) {
 			QString value = rx.cap(0);
 			int len = value.length();
 			value = rtagBracket + value.mid(1, len-2) + ltagBracket;
 			linerev.replace(pos1, len, value);
 		}
 
 		pos1 = rx.indexIn(linerev);
 		pos2 = rxfont.indexIn(linerev);
 	}
 	linerev.replace(ltagBracket, "(");
 	linerev.replace(rtagBracket, ")");
 
 	line = strreverse(linerev);
 
 	//replace \b(...), \i(...), \u(...), \g(...), \+(...), \-(...), \f:font(...) tags
 	const QString rxstr[] = { "\\\\\\s*b\\s*\\(", "\\\\\\s*i\\s*\\(", "\\\\\\s*u\\s*\\(", "\\\\\\s*g\\s*\\(", "\\\\\\s*\\+\\s*\\(", "\\\\\\s*\\-\\s*\\(", "\\\\\\s*f\\:[^\\(]*\\("};
 
 	int postag[] = {0, 0, 0, 0, 0, 0, 0};
 	QString ltag[] = {"<b>","<i>","<u>","<font face=Symbol>","<sup>","<sub>","<font face=%1>"};
 	QString rtag[] = {"</b>","</i>","</u>","</font>","</sup>","</sub>","</font>"};
 	QRegExp rxtags[7];
 	for (int i = 0; i < 7; ++i)
 		rxtags[i].setPattern(rxstr[i]+"[^\\(\\)]*\\)");
 
 	bool flag = true;
 	while (flag) {
 		for (int i = 0; i < 7; ++i) {
 			postag[i] = rxtags[i].indexIn(line);
 			while (postag[i] > -1) {
 				QString value = rxtags[i].cap(0);
 				int len = value.length();
 				pos2 = value.indexOf("(");
 				if (i < 6)
 					value = ltag[i] + value.mid(pos2+1, len-pos2-2) + rtag[i];
 				else {
 					int posfont = value.indexOf("f:");
 					value = ltag[i].arg(value.mid(posfont+2, pos2-posfont-2)) + value.mid(pos2+1, len-pos2-2) + rtag[i];
 				}
 				line.replace(postag[i], len, value);
 				postag[i] = rxtags[i].indexIn(line);
 			}
 		}
 		flag = false;
 		for (int i = 0; i < 7; ++i) {
 			if (rxtags[i].indexIn(line) > -1) {
 				flag = true;
 				break;
 			}
 		}
 	}
 
 	//replace unclosed tags
 	for (int i = 0; i < 6; ++i)
 		line.replace(QRegExp(rxstr[i]), ltag[i]);
 	rxfont.setPattern(rxstr[6]);
 	pos = rxfont.indexIn(line);
 	while (pos > -1) {
 		QString value = rxfont.cap(0);
 		int len = value.length();
 		int posfont = value.indexOf("f:");
 		value = ltag[6].arg(value.mid(posfont+2, len-posfont-3));
 		line.replace(pos, len, value);
 		pos = rxfont.indexIn(line);
 	}
 
 	line.replace("&lbracket;", "(");
 	line.replace("&rbracket;", ")");
 
 	// special characters
 	QRegExp rxs("\\\\\\((\\d+)\\)");
 	line.replace(rxs, "&#\\1;");
 
 	DEBUG("	result: " << line.toStdString());
 
 	return line;
 }
diff --git a/src/backend/gsl/ExpressionParser.cpp b/src/backend/gsl/ExpressionParser.cpp
index 26c1d8ce3..00c970981 100644
--- a/src/backend/gsl/ExpressionParser.cpp
+++ b/src/backend/gsl/ExpressionParser.cpp
@@ -1,1586 +1,1586 @@
 /***************************************************************************
     File             : ExpressionParser.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2014 Alexander Semke (alexander.semke@web.de)
     Copyright        : (C) 2014-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description      : C++ wrapper for the bison generated parser.
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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/lib/macros.h"
 #include "backend/gsl/ExpressionParser.h"
 
 #include <klocalizedstring.h>
 #include <QDebug>
 
 #include <cmath>
 extern "C" {
 #include <gsl/gsl_version.h>
 #include <gsl/gsl_errno.h>
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_const_mksa.h>
 #include <gsl/gsl_const_num.h>
 #include "backend/gsl/parser.h"
 }
 
 ExpressionParser* ExpressionParser::instance = nullptr;
 
 ExpressionParser::ExpressionParser() {
 	init_table();
 	initFunctions();
 	initConstants();
 }
 
 void ExpressionParser::initFunctions() {
 	//functions	(sync with functions.h!)
 	for (int i = 0; _functions[i].name != nullptr; i++)
 		m_functions << _functions[i].name;
 
 	m_functionsGroups << i18n("Standard Mathematical functions");
 	//http://www.gnu.org/software/gsl/manual/html_node/Special-Functions.html
 	m_functionsGroups << i18n("Airy Functions and Derivatives");
 	m_functionsGroups << i18n("Bessel Functions");
 	m_functionsGroups << i18n("Clausen Functions");
 	m_functionsGroups << i18n("Coulomb Functions");
 // 	m_functionsGroups << i18n("Coupling Coefficients");
 	m_functionsGroups << i18n("Dawson Function");
 	m_functionsGroups << i18n("Debye Functions");
 	m_functionsGroups << i18n("Dilogarithm");
 //	m_functionsGroups << i18n("Elementary Operations");
 	m_functionsGroups << i18n("Elliptic Integrals");
 //	m_functionsGroups << i18n("Elliptic Functions (Jacobi)");
 #ifndef _MSC_VER
 	m_functionsGroups << i18n("Error Functions and Related Functions");
 #else
 	m_functionsGroups << i18n("Error Functions");
 #endif
 	m_functionsGroups << i18n("Exponential Functions");
 	m_functionsGroups << i18n("Exponential Integrals");
 	m_functionsGroups << i18n("Fermi-Dirac Function");
 	m_functionsGroups << i18n("Gamma and Beta Functions");
 	m_functionsGroups << i18n("Gegenbauer Functions");
 #if (GSL_MAJOR_VERSION > 2) || (GSL_MAJOR_VERSION == 2) && (GSL_MINOR_VERSION >= 4)
 	m_functionsGroups << i18n("Hermite Polynomials and Functions");
 #endif
 	m_functionsGroups << i18n("Hypergeometric Functions");
 	m_functionsGroups << i18n("Laguerre Functions");
 	m_functionsGroups << i18n("Lambert W Functions");
 	m_functionsGroups << i18n("Legendre Functions and Spherical Harmonics");
 	m_functionsGroups << i18n("Logarithm and Related Functions");
 //	m_functionsGroups << i18n("Mathieu Functions");
 	m_functionsGroups << i18n("Power Function");
 	m_functionsGroups << i18n("Psi (Digamma) Function");
 	m_functionsGroups << i18n("Synchrotron Functions");
 	m_functionsGroups << i18n("Transport Functions");
 	m_functionsGroups << i18n("Trigonometric Functions");
 	m_functionsGroups << i18n("Zeta Functions");
 	// GSL random distribution functions
 	m_functionsGroups << i18n("Gaussian Distribution");
 	m_functionsGroups << i18n("Exponential Distribution");
 	m_functionsGroups << i18n("Laplace Distribution");
 	m_functionsGroups << i18n("Exponential Power Distribution");
 	m_functionsGroups << i18n("Cauchy Distribution");
 	m_functionsGroups << i18n("Rayleigh Distribution");
 	m_functionsGroups << i18n("Landau Distribution");
 	m_functionsGroups << i18n("Gamma Distribution");
 	m_functionsGroups << i18n("Flat (Uniform) Distribution");
 	m_functionsGroups << i18n("Lognormal Distribution");
 	m_functionsGroups << i18n("Chi-squared Distribution");
 	m_functionsGroups << i18n("F-distribution");
 	m_functionsGroups << i18n("t-distribution");
 	m_functionsGroups << i18n("Beta Distribution");
 	m_functionsGroups << i18n("Logistic Distribution");
 	m_functionsGroups << i18n("Pareto Distribution");
 	m_functionsGroups << i18n("Weibull Distribution");
 	m_functionsGroups << i18n("Gumbel Distribution");
 	m_functionsGroups << i18n("Poisson Distribution");
 	m_functionsGroups << i18n("Bernoulli Distribution");
 	m_functionsGroups << i18n("Binomial Distribution");
 	m_functionsGroups << i18n("Pascal Distribution");
 	m_functionsGroups << i18n("Geometric Distribution");
 	m_functionsGroups << i18n("Hypergeometric Distribution");
 	m_functionsGroups << i18n("Logarithmic Distribution");
 
 	int index = 0;
 
 	// Standard mathematical functions
 	m_functionsNames << i18n("pseudo-random integer [0,RAND_MAX]");
 	m_functionsNames << i18n("nonlinear additive feedback rng [0,RAND_MAX]");
 	m_functionsNames << i18n("nonlinear additive feedback rng [0,1]");
 	m_functionsNames << i18n("Smallest integral value not less");
 	m_functionsNames << i18n("Absolute value");
 
 	m_functionsNames << i18n("Base 10 logarithm");
 	m_functionsNames << i18n("Power function [x^y]");
 	m_functionsNames << i18n("Nonnegative square root");
 	m_functionsNames << i18n("Sign function");
 	m_functionsNames << i18n("Heavyside theta function");
 	m_functionsNames << i18n("Harmonic number function");
 
 #ifndef HAVE_WINDOWS
 	m_functionsNames << i18n("Cube root");
 	m_functionsNames << i18n("Extract the exponent");
 	m_functionsNames << i18n("Round to an integer value");
 	m_functionsNames << i18n("Round to the nearest integer");
 	m_functionsNames << i18n("Round to the nearest integer");
 #endif
 	m_functionsNames << QString("log(1+x)");
 	m_functionsNames << QString("x * 2^e");
 	m_functionsNames << QString("x^n");
 	m_functionsNames << QString("x^2");
 	m_functionsNames << QString("x^3");
 	m_functionsNames << QString("x^4");
 	m_functionsNames << QString("x^5");
 	m_functionsNames << QString("x^6");
 	m_functionsNames << QString("x^7");
 	m_functionsNames << QString("x^8");
 	m_functionsNames << QString("x^9");
 
 #ifndef HAVE_WINDOWS
 	for (int i = 0; i < 27; i++)
 #else
 	for (int i = 0; i < 22; i++)
 #endif
 		m_functionsGroupIndex << index;
 
 	// Airy Functions and Derivatives
 	m_functionsNames << i18n("Airy function of the first kind");
 	m_functionsNames << i18n("Airy function of the second kind");
 	m_functionsNames << i18n("Scaled Airy function of the first kind");
 	m_functionsNames << i18n("Scaled Airy function of the second kind");
 	m_functionsNames << i18n("Airy function derivative of the first kind");
 	m_functionsNames << i18n("Airy function derivative of the second kind");
 	m_functionsNames << i18n("Scaled Airy function derivative of the first kind");
 	m_functionsNames << i18n("Scaled Airy function derivative of the second kind");
 	m_functionsNames << i18n("n-th zero of the Airy function of the first kind");
 	m_functionsNames << i18n("n-th zero of the Airy function of the second kind");
 	m_functionsNames << i18n("n-th zero of the Airy function derivative of the first kind");
 	m_functionsNames << i18n("n-th zero of the Airy function derivative of the second kind");
 
 	index++;
 	for (int i = 0; i < 12; i++)
 		m_functionsGroupIndex << index;
 
 	// Bessel Functions
 	m_functionsNames << i18n("Regular cylindrical Bessel function of zeroth order");
 	m_functionsNames << i18n("Regular cylindrical Bessel function of first order");
 	m_functionsNames << i18n("Regular cylindrical Bessel function of order n");
 	m_functionsNames << i18n("Irregular cylindrical Bessel function of zeroth order");
 	m_functionsNames << i18n("Irregular cylindrical Bessel function of first order");
 	m_functionsNames << i18n("Irregular cylindrical Bessel function of order n");
 	m_functionsNames << i18n("Regular modified cylindrical Bessel function of zeroth order");
 	m_functionsNames << i18n("Regular modified cylindrical Bessel function of first order");
 	m_functionsNames << i18n("Regular modified cylindrical Bessel function of order n");
 	m_functionsNames << i18n("Scaled regular modified cylindrical Bessel function of zeroth order exp(-|x|) I0(x)");
 
 	m_functionsNames << i18n("Scaled regular modified cylindrical Bessel function of first order exp(-|x|) I1(x)");
 	m_functionsNames << i18n("Scaled regular modified cylindrical Bessel function of order n exp(-|x|) In(x)");
 	m_functionsNames << i18n("Irregular modified cylindrical Bessel function of zeroth order");
 	m_functionsNames << i18n("Irregular modified cylindrical Bessel function of first order");
 	m_functionsNames << i18n("Irregular modified cylindrical Bessel function of order n");
 	m_functionsNames << i18n("Scaled irregular modified cylindrical Bessel function of zeroth order exp(x) K0(x)");
 	m_functionsNames << i18n("Scaled irregular modified cylindrical Bessel function of first order exp(x) K1(x)");
 	m_functionsNames << i18n("Scaled irregular modified cylindrical Bessel function of order n exp(x) Kn(x)");
 	m_functionsNames << i18n("Regular spherical Bessel function of zeroth order");
 	m_functionsNames << i18n("Regular spherical Bessel function of first order");
 
 	m_functionsNames << i18n("Regular spherical Bessel function of second order");
 	m_functionsNames << i18n("Regular spherical Bessel function of order l");
 	m_functionsNames << i18n("Irregular spherical Bessel function of zeroth order");
 	m_functionsNames << i18n("Irregular spherical Bessel function of first order");
 	m_functionsNames << i18n("Irregular spherical Bessel function of second order");
 	m_functionsNames << i18n("Irregular spherical Bessel function of order l");
 	m_functionsNames << i18n("Scaled regular modified spherical Bessel function of zeroth order, exp(-|x|) i0(x)");
 	m_functionsNames << i18n("Scaled regular modified spherical Bessel function of first order, exp(-|x|) i1(x)");
 	m_functionsNames << i18n("Scaled regular modified spherical Bessel function of second order, exp(-|x|) i2(x)");
 	m_functionsNames << i18n("Scaled regular modified spherical Bessel function of order l, exp(-|x|) il(x)");
 
 	m_functionsNames << i18n("Scaled irregular modified spherical Bessel function of zeroth order, exp(x) k0(x)");
 	m_functionsNames << i18n("Scaled irregular modified spherical Bessel function of first order, exp(-|x|) k1(x)");
 	m_functionsNames << i18n("Scaled irregular modified spherical Bessel function of second order, exp(-|x|) k2(x)");
 	m_functionsNames << i18n("Scaled irregular modified spherical Bessel function of order l, exp(-|x|) kl(x)");
 	m_functionsNames << i18n("Regular cylindrical Bessel function of fractional order");
 	m_functionsNames << i18n("Irregular cylindrical Bessel function of fractional order");
 	m_functionsNames << i18n("Regular modified Bessel function of fractional order");
 	m_functionsNames << i18n("Scaled regular modified Bessel function of fractional order");
 	m_functionsNames << i18n("Irregular modified Bessel function of fractional order");
 	m_functionsNames << i18n("Logarithm of irregular modified Bessel function of fractional order");
 
 	m_functionsNames << i18n("Scaled irregular modified Bessel function of fractional order");
 	m_functionsNames << i18n("n-th positive zero of the Bessel function J0");
 	m_functionsNames << i18n("n-th positive zero of the Bessel function J1");
 	m_functionsNames << i18n("n-th positive zero of the Bessel function Jnu");
 
 	index++;
 	for (int i = 0; i < 44; i++)
 		m_functionsGroupIndex << index;
 
 	// Clausen Functions
 	m_functionsNames << i18n("Clausen function");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Coulomb Functions
 	m_functionsNames << i18n("Lowest-order normalized hydrogenic bound state radial wavefunction");
 	m_functionsNames << i18n("n-th normalized hydrogenic bound state radial wavefunction");
 
 	index++;
 	for (int i = 0; i < 2; i++)
 		m_functionsGroupIndex << index;
 
 	// Dawson Function
 	m_functionsNames << i18n("Dawson integral");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Debye Functions
 	m_functionsNames << i18n("First-order Debye function");
 	m_functionsNames << i18n("Second-order Debye function");
 	m_functionsNames << i18n("Third-order Debye function");
 	m_functionsNames << i18n("Fourth-order Debye function");
 	m_functionsNames << i18n("Fifth-order Debye function");
 	m_functionsNames << i18n("Sixth-order Debye function");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 
 	// Dilogarithm
 	m_functionsNames << i18n("Dilogarithm for a real argument");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Elliptic Integrals
 	m_functionsNames << i18n("Legendre form of complete elliptic integral K");
 	m_functionsNames << i18n("Legendre form of complete elliptic integral E");
 	m_functionsNames << i18n("Legendre form of complete elliptic integral Pi");
 	m_functionsNames << i18n("Legendre form of incomplete elliptic integral F");
 	m_functionsNames << i18n("Legendre form of incomplete elliptic integral E");
 	m_functionsNames << i18n("Legendre form of incomplete elliptic integral P");
 	m_functionsNames << i18n("Legendre form of incomplete elliptic integral D");
 	m_functionsNames << i18n("Carlson form of incomplete elliptic integral RC");
 	m_functionsNames << i18n("Carlson form of incomplete elliptic integral RD");
 	m_functionsNames << i18n("Carlson form of incomplete elliptic integral RF");
 	m_functionsNames << i18n("Carlson form of incomplete elliptic integral RJ");
 
 	index++;
 	for (int i = 0; i < 11; i++)
 		m_functionsGroupIndex << index;
 
 	// Error Functions
 	m_functionsNames << i18n("Error function");
 	m_functionsNames << i18n("Complementary error function");
 	m_functionsNames << i18n("Logarithm of complementary error function");
 	m_functionsNames << i18n("Gaussian probability density function Z");
 	m_functionsNames << i18n("Upper tail of the Gaussian probability function Q");
 	m_functionsNames << i18n("Hazard function for the normal distribution Z/Q");
 	int count = 6;
 #ifndef _MSC_VER
 	m_functionsNames << i18n("Underflow-compensating function exp(x^2) erfc(x) for real x");
 	m_functionsNames << i18n("Imaginary error function erfi(x) = -i erf(ix) for real x");
 	m_functionsNames << i18n("Imaginary part of Faddeeva's scaled complex error function w(x) = exp(-x^2) erfc(-ix) for real x");
 	m_functionsNames << i18n("Dawson's integral D(z) = sqrt(pi)/2 * exp(-z^2) * erfi(z)");
 	m_functionsNames << i18n("Voigt profile");
 	count += 5;
 #endif
 	m_functionsNames << i18n("Pseudo-Voigt profile (same width)");
 	count += 1;
 
 	index++;
 	for (int i = 0; i < count; i++)
 		m_functionsGroupIndex << index;
 
 	// Exponential Functions
 	m_functionsNames << i18n("Exponential function");
 	m_functionsNames << i18n("exponentiate x and multiply by y");
 	m_functionsNames << QString("exp(x) - 1");
 	m_functionsNames << QString("(exp(x)-1)/x");
 	m_functionsNames << QString("2(exp(x)-1-x)/x^2");
 	m_functionsNames << i18n("n-relative exponential");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 
 	// Exponential Integrals
 	m_functionsNames << i18n("Exponential integral");
 	m_functionsNames << i18n("Second order exponential integral");
 	m_functionsNames << i18n("Exponential integral of order n");
 	m_functionsNames << i18n("Exponential integral Ei");
 	m_functionsNames << i18n("Hyperbolic integral Shi");
 	m_functionsNames << i18n("Hyperbolic integral Chi");
 	m_functionsNames << i18n("Third-order exponential integral");
 	m_functionsNames << i18n("Sine integral");
 	m_functionsNames << i18n("Cosine integral");
 	m_functionsNames << i18n("Arctangent integral");
 
 	index++;
 	for (int i = 0; i < 10; i++)
 		m_functionsGroupIndex << index;
 
 	// Fermi-Dirac Function
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index -1");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index 0");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index 1");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index 2");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with integer index j");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index -1/2");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index 1/2");
 	m_functionsNames << i18n("Complete Fermi-Dirac integral with index 3/2");
 	m_functionsNames << i18n("Incomplete Fermi-Dirac integral with index zero");
 
 	index++;
 	for (int i = 0; i < 9; i++)
 		m_functionsGroupIndex << index;
 
 	// Gamma and Beta Functions
 	m_functionsNames << i18n("Gamma function");
 	m_functionsNames << i18n("Gamma function");
 	m_functionsNames << i18n("Logarithm of the gamma function");
 	m_functionsNames << i18n("Logarithm of the gamma function");
 	m_functionsNames << i18n("Regulated gamma function");
 	m_functionsNames << i18n("Reciprocal of the gamma function");
 	m_functionsNames << i18n("Factorial n!");
 	m_functionsNames << i18n("Double factorial n!!");
 	m_functionsNames << i18n("Logarithm of the factorial");
 	m_functionsNames << i18n("Logarithm of the double factorial");
 
 	m_functionsNames << i18n("Combinatorial factor");
 	m_functionsNames << i18n("Logarithm of the combinatorial factor");
 	m_functionsNames << i18n("Taylor coefficient");
 	m_functionsNames << i18n("Pochhammer symbol");
 	m_functionsNames << i18n("Logarithm of the Pochhammer symbol");
 	m_functionsNames << i18n("Relative Pochhammer symbol");
 	m_functionsNames << i18n("Unnormalized incomplete gamma function");
 	m_functionsNames << i18n("Normalized incomplete gamma function");
 	m_functionsNames << i18n("Complementary normalized incomplete gamma function");
 	m_functionsNames << i18n("Beta function");
 
 	m_functionsNames << i18n("Logarithm of the beta function");
 	m_functionsNames << i18n("Normalized incomplete beta function");
 
 	index++;
 	for (int i = 0; i < 22; i++)
 		m_functionsGroupIndex << index;
 
 	// Gegenbauer Functions
 	m_functionsNames << i18n("Gegenbauer polynomial C_1");
 	m_functionsNames << i18n("Gegenbauer polynomial C_2");
 	m_functionsNames << i18n("Gegenbauer polynomial C_3");
 	m_functionsNames << i18n("Gegenbauer polynomial C_n");
 
 	index++;
 	for (int i = 0; i < 4; i++)
 		m_functionsGroupIndex << index;
 
 #if (GSL_MAJOR_VERSION > 2) || (GSL_MAJOR_VERSION == 2) && (GSL_MINOR_VERSION >= 4)
 	// Hermite Polynomials and Functions
 	m_functionsNames << i18n("Hermite polynomials physicists version");
 	m_functionsNames << i18n("Hermite polynomials probabilists version");
 	m_functionsNames << i18n("Hermite functions");
 	m_functionsNames << i18n("Derivatives of Hermite polynomials physicists version");
 	m_functionsNames << i18n("Derivatives of Hermite polynomials probabilists version");
 	m_functionsNames << i18n("Derivatives of Hermite functions");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 #endif
 
 	// Hypergeometric Functions
 	m_functionsNames << i18n("Hypergeometric function 0F1");
 	m_functionsNames << i18n("Confluent hypergeometric function 1F1 for integer parameters");
 	m_functionsNames << i18n("Confluent hypergeometric function 1F1 for general parameters");
 	m_functionsNames << i18n("Confluent hypergeometric function U for integer parameters");
 	m_functionsNames << i18n("Confluent hypergeometric function U");
 	m_functionsNames << i18n("Gauss hypergeometric function 2F1");
 	m_functionsNames << i18n("Gauss hypergeometric function 2F1 with complex parameters");
 	m_functionsNames << i18n("Renormalized Gauss hypergeometric function 2F1");
 	m_functionsNames << i18n("Renormalized Gauss hypergeometric function 2F1 with complex parameters");
 	m_functionsNames << i18n("Hypergeometric function 2F0");
 
 	index++;
 	for (int i = 0; i < 10; i++)
 		m_functionsGroupIndex << index;
 
 	// Laguerre Functions
 	m_functionsNames << i18n("generalized Laguerre polynomials L_1");
 	m_functionsNames << i18n("generalized Laguerre polynomials L_2");
 	m_functionsNames << i18n("generalized Laguerre polynomials L_3");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Lambert W Functions
 	m_functionsNames << i18n("Principal branch of the Lambert W function");
 	m_functionsNames << i18n("Secondary real-valued branch of the Lambert W function");
 
 	index++;
 	for (int i = 0; i < 2; i++)
 		m_functionsGroupIndex << index;
 
 	// Legendre Functions and Spherical Harmonics
 	m_functionsNames << i18n("Legendre polynomial P_1");
 	m_functionsNames << i18n("Legendre polynomial P_2");
 	m_functionsNames << i18n("Legendre polynomial P_3");
 	m_functionsNames << i18n("Legendre polynomial P_l");
 	m_functionsNames << i18n("Legendre function Q_0");
 	m_functionsNames << i18n("Legendre function Q_1");
 	m_functionsNames << i18n("Legendre function Q_l");
 	m_functionsNames << i18n("Associated Legendre polynomial");
 	m_functionsNames << i18n("Normalized associated Legendre polynomial");
 	m_functionsNames << i18n("Irregular spherical conical function P^1/2");
 
 	m_functionsNames << i18n("Regular spherical conical function P^(-1/2)");
 	m_functionsNames << i18n("Conical function P^0");
 	m_functionsNames << i18n("Conical function P^1");
 	m_functionsNames << i18n("Regular spherical conical function P^(-1/2-l)");
 	m_functionsNames << i18n("Regular cylindrical conical function P^(-m)");
 	m_functionsNames << i18n("Zeroth radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space");
 	m_functionsNames << i18n("First radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space");
 	m_functionsNames << i18n("l-th radial eigenfunction of the Laplacian on the 3-dimensional hyperbolic space");
 
 	index++;
 	for (int i = 0; i < 18; i++)
 		m_functionsGroupIndex << index;
 
 	// Logarithm and Related Functions
 	m_functionsNames << i18n("Logarithm");
 	m_functionsNames << i18n("Logarithm of the magnitude");
 	m_functionsNames << QString("log(1+x)");
 	m_functionsNames << QString("log(1+x) - x");
 
 	index++;
 	for (int i = 0; i < 4; i++)
 		m_functionsGroupIndex << index;
 
 	// Power Function
 	m_functionsNames << i18n("x^n for integer n with an error estimate");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Psi (Digamma) Function
 	m_functionsNames << i18n("Digamma function for positive integer n");
 	m_functionsNames << i18n("Digamma function");
 	m_functionsNames << i18n("Real part of the digamma function on the line 1+i y");
 	m_functionsNames << i18n("Trigamma function psi' for positive integer n");
 	m_functionsNames << i18n("Trigamma function psi'");
 	m_functionsNames << i18n("Polygamma function psi^(n)");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 
 	// Synchrotron Functions
 	m_functionsNames << i18n("First synchrotron function");
 	m_functionsNames << i18n("Second synchrotron function");
 
 	index++;
 	for (int i = 0; i < 2; i++)
 		m_functionsGroupIndex << index;
 
 	// Transport Functions
 	m_functionsNames << i18n("Transport function");
 	m_functionsNames << i18n("Transport function");
 	m_functionsNames << i18n("Transport function");
 	m_functionsNames << i18n("Transport function");
 
 	index++;
 	for (int i = 0; i < 4; i++)
 		m_functionsGroupIndex << index;
 
 	// Trigonometric Functions
 	m_functionsNames << i18n("Sine");
 	m_functionsNames << i18n("Cosine");
 	m_functionsNames << i18n("Tangent");
 	m_functionsNames << i18n("Inverse sine");
 	m_functionsNames << i18n("Inverse cosine");
 	m_functionsNames << i18n("Inverse tangent");
 	m_functionsNames << i18n("Inverse tangent using sign");
 	m_functionsNames << i18n("Hyperbolic sine");
 	m_functionsNames << i18n("Hyperbolic cosine");
 	m_functionsNames << i18n("Hyperbolic tangent");
 	m_functionsNames << i18n("Inverse hyperbolic cosine");
 	m_functionsNames << i18n("Inverse hyperbolic sine");
 	m_functionsNames << i18n("Inverse hyperbolic tangent");
 	m_functionsNames << i18n("Secant");
 	m_functionsNames << i18n("Cosecant");
 	m_functionsNames << i18n("Cotangent");
 	m_functionsNames << i18n("Inverse secant");
 	m_functionsNames << i18n("Inverse cosecant");
 	m_functionsNames << i18n("Inverse cotangent");
 	m_functionsNames << i18n("Hyperbolic secant");
 	m_functionsNames << i18n("Hyperbolic cosecant");
 	m_functionsNames << i18n("Hyperbolic cotangent");
 	m_functionsNames << i18n("Inverse hyperbolic secant");
 	m_functionsNames << i18n("Inverse hyperbolic cosecant");
 	m_functionsNames << i18n("Inverse hyperbolic cotangent");
 	m_functionsNames << i18n("Sinc function sin(x)/x");
 	m_functionsNames << QString("log(sinh(x))");
 	m_functionsNames << QString("log(cosh(x))");
 	m_functionsNames << i18n("Hypotenuse function");
 	m_functionsNames << i18n("Three component hypotenuse function");
 	m_functionsNames << i18n("restrict to [-pi,pi]");
 	m_functionsNames << i18n("restrict to [0,2 pi]");
 
 	index++;
 	for (int i = 0; i < 32; i++)
 		m_functionsGroupIndex << index;
 
 	// Zeta Functions
 	m_functionsNames << i18n("Riemann zeta function for integer n");
 	m_functionsNames << i18n("Riemann zeta function");
 	m_functionsNames << i18n("zeta(n)-1 for integer n");
 	m_functionsNames << i18n("zeta(x)-1");
 	m_functionsNames << i18n("Hurwitz zeta function");
 	m_functionsNames << i18n("Eta function for integer n");
 	m_functionsNames << i18n("Eta function");
 
 	index++;
 	for (int i = 0; i < 7; i++)
 		m_functionsGroupIndex << index;
 
 	// GSL Random Number Distributions: see http://www.gnu.org/software/gsl/manual/html_node/Random-Number-Distributions.html
 	// Gaussian Distribution
 	m_functionsNames << i18n("Probability density for a Gaussian distribution");
 	m_functionsNames << i18n("Probability density for a unit Gaussian distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 	m_functionsNames << i18n("Cumulative unit distribution function P");
 	m_functionsNames << i18n("Cumulative unit distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative unit distribution function P");
 	m_functionsNames << i18n("Inverse cumulative unit distribution function Q");
 
 	m_functionsNames << i18n("Probability density for Gaussian tail distribution");
 	m_functionsNames << i18n("Probability density for unit Gaussian tail distribution");
 	m_functionsNames << i18n("Probability density for a bivariate Gaussian distribution");
 
 	index++;
 	for (int i = 0; i < 13; i++)
 		m_functionsGroupIndex << index;
 
 	// Exponential Distribution
 	m_functionsNames << i18n("Probability density for an exponential distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Laplace Distribution
 	m_functionsNames << i18n("Probability density for a Laplace distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Exponential Power Distribution
 	m_functionsNames << i18n("Probability density for an exponential power distribution");
 	m_functionsNames << i18n("cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Cauchy Distribution
 	m_functionsNames << i18n("Probability density for a Cauchy distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Rayleigh Distribution
 	m_functionsNames << i18n("Probability density for a Rayleigh distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 	m_functionsNames << i18n("Probability density for a Rayleigh tail distribution");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 
 	// Landau Distribution
 	m_functionsNames << i18n("Probability density for a Landau distribution");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Gamma Distribution
 	m_functionsNames << i18n("Probability density for a gamma distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Flat (Uniform) Distribution
 	m_functionsNames << i18n("Probability density for a uniform distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Lognormal Distribution
 	m_functionsNames << i18n("Probability density for a lognormal distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Chi-squared Distribution
 	m_functionsNames << i18n("Probability density for a chi squared distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// F-distribution
 	m_functionsNames << i18n("Probability density for a F-distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// t-distribution
 	m_functionsNames << i18n("Probability density for a t-distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Beta Distribution
 	m_functionsNames << i18n("Probability density for a beta distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Logistic Distribution
 	m_functionsNames << i18n("Probability density for a logistic distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Pareto Distribution
 	m_functionsNames << i18n("Probability density for a Pareto distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Weibull Distribution
 	m_functionsNames << i18n("Probability density for a Weibull distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 5; i++)
 		m_functionsGroupIndex << index;
 
 	// Gumbel Distribution
 	m_functionsNames << i18n("Probability density for a Type-1 Gumbel distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 	m_functionsNames << i18n("Probability density for a Type-2 Gumbel distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Inverse cumulative distribution function P");
 	m_functionsNames << i18n("Inverse cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 10; i++)
 		m_functionsGroupIndex << index;
 
 	// Poisson Distribution
 	m_functionsNames << i18n("Probability density for a Poisson distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Bernoulli Distribution
 	m_functionsNames << i18n("Probability density for a Bernoulli distribution");
 	index++;
 	m_functionsGroupIndex << index;
 
 	// Binomial Distribution
 	m_functionsNames << i18n("Probability density for a binomial distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 	m_functionsNames << i18n("Probability density for a negative binomial distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 6; i++)
 		m_functionsGroupIndex << index;
 
 	// Pascal Distribution
 	m_functionsNames << i18n("Probability density for a Pascal distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Geometric Distribution
 	m_functionsNames << i18n("Probability density for a geometric distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Hypergeometric Distribution
 	m_functionsNames << i18n("Probability density for a hypergeometric distribution");
 	m_functionsNames << i18n("Cumulative distribution function P");
 	m_functionsNames << i18n("Cumulative distribution function Q");
 
 	index++;
 	for (int i = 0; i < 3; i++)
 		m_functionsGroupIndex << index;
 
 	// Logarithmic Distribution
 	m_functionsNames << i18n("Probability density for a logarithmic distribution");
 	index++;
 	m_functionsGroupIndex << index;
 }
 
 //TODO: decide whether we want to have i18n here in the backend part of the code
 void ExpressionParser::initConstants() {
 	for (int i = 0; _constants[i].name != nullptr; i++)
 		m_constants << _constants[i].name;
 
 	//groups
 	m_constantsGroups << i18n("Mathematical constants");
 	m_constantsGroups << i18n("Fundamental constants");
 	m_constantsGroups << i18n("Astronomy and Astrophysics");
 	m_constantsGroups << i18n("Atomic and Nuclear Physics");
 	m_constantsGroups << i18n("Measurement of Time");
 	m_constantsGroups << i18n("Imperial Units");
 	m_constantsGroups << i18n("Speed and Nautical Units");
 	m_constantsGroups << i18n("Printers Units");
 	m_constantsGroups << i18n("Volume, Area and Length");
 	m_constantsGroups << i18n("Mass and Weight");
 	m_constantsGroups << i18n("Thermal Energy and Power");
 	m_constantsGroups << i18n("Pressure");
 	m_constantsGroups << i18n("Viscosity");
 	m_constantsGroups << i18n("Light and Illumination");
 	m_constantsGroups << i18n("Radioactivity");
 	m_constantsGroups << i18n("Force and Energy");
 
 	//Mathematical constants
 	m_constantsNames << i18n("Base of exponentials");
 	m_constantsValues << QString::number(M_E,'g',15);
 	m_constantsUnits << "";
 	m_constantsNames << i18n("Pi");
 	m_constantsValues << QString::number(M_PI,'g',15);
 	m_constantsUnits << "";
 	m_constantsNames << i18n("Euler's constant");
 	m_constantsValues << QString::number(M_EULER,'g',15);
 	m_constantsUnits << "";
 
 	for (int i = 0; i < 3; i++)
 		m_constantsGroupIndex << 0;
 
 	//Fundamental constants
 	m_constantsNames << i18n("Speed of light");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_SPEED_OF_LIGHT,'g',15);
 	m_constantsUnits << "m / s";
 	m_constantsNames << i18n("Vacuum permeability");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_VACUUM_PERMEABILITY,'g',15);
 	m_constantsUnits << "kg m / A^2 s^2";
 	m_constantsNames << i18n("Vacuum permittivity");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_VACUUM_PERMITTIVITY,'g',15);
 	m_constantsUnits << "A^2 s^4 / kg m^3";
 	m_constantsNames << i18n("Planck constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PLANCKS_CONSTANT_H,'g',15);
 	m_constantsUnits << "kg m^2 / s";
 	m_constantsNames << i18n("Reduced Planck constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR,'g',15);
 	m_constantsUnits << "kg m^2 / s";
 	m_constantsNames << i18n("Avogadro constant");
 	m_constantsValues << QString::number(GSL_CONST_NUM_AVOGADRO,'g',15);
 	m_constantsUnits << "1 / mol";
 	m_constantsNames << i18n("Faraday");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_FARADAY,'g',15);
 	m_constantsUnits << "A s / mol";
 	m_constantsNames << i18n("Boltzmann constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BOLTZMANN,'g',15);
 	m_constantsUnits << "kg m^2 / K s^2";
 	m_constantsNames << i18n("Molar gas");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MOLAR_GAS,'g',15);
 	m_constantsUnits << "kg m^2 / K mol s^2";
 	m_constantsNames << i18n("Standard gas volume");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_STANDARD_GAS_VOLUME,'g',15);
 	m_constantsUnits << "m^3 / mol";
 	m_constantsNames << i18n("Stefan-Boltzmann constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT,'g',15);
 	m_constantsUnits << "kg / K^4 s^3";
 	m_constantsNames << i18n("Gauss");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_GAUSS,'g',15);
 	m_constantsUnits << "kg / A s^2";
 
 	for (int i = 0; i < 12; i++)
 		m_constantsGroupIndex << 1;
 
 	// Astronomy and Astrophysics
 	m_constantsNames << i18n("Astronomical unit");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ASTRONOMICAL_UNIT,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Gravitational constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT,'g',15);
 	m_constantsUnits << "m^3 / kg s^2";
 	m_constantsNames << i18n("Light year");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_LIGHT_YEAR,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Parsec");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PARSEC,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Gravitational acceleration");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_GRAV_ACCEL,'g',15);
 	m_constantsUnits << "m / s^2";
 	m_constantsNames << i18n("Solar mass");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_SOLAR_MASS,'g',15);
 	m_constantsUnits << "kg";
 
 	for (int i = 0; i < 6; i++)
 		m_constantsGroupIndex << 2;
 
 	// Atomic and Nuclear Physics;
 	m_constantsNames << i18n("Charge of the electron");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ELECTRON_CHARGE,'g',15);
 	m_constantsUnits << "A s";
 	m_constantsNames << i18n("Energy of 1 electron volt");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ELECTRON_VOLT,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Unified atomic mass");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of the electron");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MASS_ELECTRON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of the muon");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MASS_MUON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of the proton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MASS_PROTON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of the neutron");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MASS_NEUTRON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Electromagnetic fine structure constant");
 	m_constantsValues << QString::number(GSL_CONST_NUM_FINE_STRUCTURE,'g',15);
 	m_constantsUnits << "";
 	m_constantsNames << i18n("Rydberg constant");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_RYDBERG,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Bohr radius");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BOHR_RADIUS,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1 angstrom");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ANGSTROM,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Area of 1 barn");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BARN,'g',15);
 	m_constantsUnits << "m^2";
 	m_constantsNames << i18n("Bohr Magneton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BOHR_MAGNETON,'g',15);
 	m_constantsUnits << "A m^2";
 	m_constantsNames << i18n("Nuclear Magneton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_NUCLEAR_MAGNETON,'g',15);
 	m_constantsUnits << "A m^2";
 	m_constantsNames << i18n("Magnetic moment of the electron [absolute value]");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT,'g',15);
 	m_constantsUnits << "A m^2";
 	m_constantsNames << i18n("Magnetic moment of the proton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT,'g',15);
 	m_constantsUnits << "A m^2";
 	m_constantsNames << i18n("Thomson cross section");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_THOMSON_CROSS_SECTION,'g',15);
 	m_constantsUnits << "m^2";
 	m_constantsNames << i18n("Electric dipole moment of 1 Debye");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_DEBYE,'g',15);
 	m_constantsUnits << "A s^2 / m^2";
 
 	for (int i = 0; i < 18; i++)
 		m_constantsGroupIndex << 3;
 
 	// Measurement of Time
 	m_constantsNames << i18n("Number of seconds in 1 minute");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MINUTE,'g',15);
 	m_constantsUnits << "s";
 	m_constantsNames << i18n("Number of seconds in 1 hour");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_HOUR,'g',15);
 	m_constantsUnits << "s";
 	m_constantsNames << i18n("Number of seconds in 1 day");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_DAY,'g',15);
 	m_constantsUnits << "s";
 	m_constantsNames << i18n("Number of seconds in 1 week");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_WEEK,'g',15);
 	m_constantsUnits << "s";
 
 	for (int i = 0; i < 4; i++)
 		m_constantsGroupIndex << 4;
 
 	// Imperial Units
 	m_constantsNames << i18n("Length of 1 inch");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_INCH,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1 foot");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_FOOT,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1 yard");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_YARD,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1 mile");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MILE,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1/1000th of an inch");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MIL,'g',15);
 	m_constantsUnits << "m";
 
 	for (int i = 0; i < 5; i++)
 		m_constantsGroupIndex << 5;
 
 	// Speed and Nautical Units
 	m_constantsNames << i18n("Speed of 1 kilometer per hour");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_KILOMETERS_PER_HOUR,'g',15);
 	m_constantsUnits << "m / s";
 	m_constantsNames << i18n("Speed of 1 mile per hour");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MILES_PER_HOUR,'g',15);
 	m_constantsUnits << "m / s";
 	m_constantsNames << i18n("Length of 1 nautical mile");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_NAUTICAL_MILE,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Length of 1 fathom");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_FATHOM,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Speed of 1 knot");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_KNOT,'g',15);
 	m_constantsUnits << "m / s";
 
 	for (int i = 0; i < 5; i++)
 		m_constantsGroupIndex << 6;
 
 	// Printers Units
 	m_constantsNames << i18n("length of 1 printer's point [1/72 inch]");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_POINT,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("length of 1 TeX point [1/72.27 inch]");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_TEXPOINT,'g',15);
 	m_constantsUnits << "m";
 
 	for (int i = 0; i < 2; i++)
 		m_constantsGroupIndex << 7;
 
 	// Volume, Area and Length
 	m_constantsNames << i18n("Length of 1 micron");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_MICRON,'g',15);
 	m_constantsUnits << "m";
 	m_constantsNames << i18n("Area of 1 hectare");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_HECTARE,'g',15);
 	m_constantsUnits << "m^2";
 	m_constantsNames << i18n("Area of 1 acre");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ACRE,'g',15);
 	m_constantsUnits << "m^2";
 	m_constantsNames << i18n("Volume of 1 liter");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_LITER,'g',15);
 	m_constantsUnits << "m^3";
 	m_constantsNames << i18n("Volume of 1 US gallon");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_US_GALLON,'g',15);
 	m_constantsUnits << "m^3";
 	m_constantsNames << i18n("Volume of 1 Canadian gallon");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_CANADIAN_GALLON,'g',15);
 	m_constantsUnits << "m^3";
 	m_constantsNames << i18n("Volume of 1 UK gallon");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_UK_GALLON,'g',15);
 	m_constantsUnits << "m^3";
 	m_constantsNames << i18n("Volume of 1 quart");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_QUART,'g',15);
 	m_constantsUnits << "m^3";
 	m_constantsNames << i18n("Volume of 1 pint");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PINT,'g',15);
 	m_constantsUnits << "m^3";
 
 	for (int i = 0; i < 9; i++)
 		m_constantsGroupIndex << 8;
 
 	// Mass and Weight
 	m_constantsNames << i18n("Mass of 1 pound");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_POUND_MASS,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 ounce");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_OUNCE_MASS,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 ton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_TON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 metric ton [1000 kg]");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_METRIC_TON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 UK ton");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_UK_TON,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 troy ounce");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_TROY_OUNCE,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Mass of 1 carat");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_CARAT,'g',15);
 	m_constantsUnits << "kg";
 	m_constantsNames << i18n("Force of 1 gram weight");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_GRAM_FORCE,'g',15);
 	m_constantsUnits << "kg m / s^2";
 	m_constantsNames << i18n("Force of 1 pound weight");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_POUND_FORCE,'g',15);
 	m_constantsUnits << "kg m / s^2";
 	m_constantsNames << i18n("Force of 1 kilopound weight");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_KILOPOUND_FORCE,'g',15);
 	m_constantsUnits << "kg m / s^2";
 	m_constantsNames << i18n("Force of 1 poundal");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_POUNDAL,'g',15);
 	m_constantsUnits << "kg m / s^2";
 
 	for (int i = 0; i < 11; i++)
 		m_constantsGroupIndex << 9;
 
 	// Thermal Energy and Power
 	m_constantsNames << i18n("Energy of 1 calorie");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_CALORIE,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Energy of 1 British Thermal Unit");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BTU,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Energy of 1 Therm");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_THERM,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Power of 1 horsepower");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_HORSEPOWER,'g',15);
 	m_constantsUnits << "kg m^2 / s^3";
 
 	for (int i = 0; i < 4; i++)
 		m_constantsGroupIndex << 10;
 
 	// Pressure
 	m_constantsNames << i18n("Pressure of 1 bar");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_BAR,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 standard atmosphere");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_STD_ATMOSPHERE,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 torr");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_TORR,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 meter of mercury");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_METER_OF_MERCURY,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 inch of mercury");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_INCH_OF_MERCURY,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 inch of water");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_INCH_OF_WATER,'g',15);
 	m_constantsUnits << "kg / m s^2";
 	m_constantsNames << i18n("Pressure of 1 pound per square inch");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PSI,'g',15);
 	m_constantsUnits << "kg / m s^2";
 
 	for (int i = 0; i < 7; i++)
 		m_constantsGroupIndex << 11;
 
 	// Viscosity
 	m_constantsNames << i18n("Dynamic viscosity of 1 poise");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_POISE,'g',15);
 	m_constantsUnits << "kg / m s";
 	m_constantsNames << i18n("Kinematic viscosity of 1 stokes");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_STOKES,'g',15);
 	m_constantsUnits << "m^2 / s";
 
 	for (int i = 0; i < 2; i++)
 		m_constantsGroupIndex << 12;
 
 	// Light and Illumination
 	m_constantsNames << i18n("Luminance of 1 stilb");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_STILB,'g',15);
 	m_constantsUnits << "cd / m^2";
 	m_constantsNames << i18n("Luminous flux of 1 lumen");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_LUMEN,'g',15);
 	m_constantsUnits << "cd sr";
 	m_constantsNames << i18n("Illuminance of 1 lux");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_LUX,'g',15);
 	m_constantsUnits << "cd sr / m^2";
 	m_constantsNames << i18n("Illuminance of 1 phot");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_PHOT,'g',15);
 	m_constantsUnits << "cd sr / m^2";
 	m_constantsNames << i18n("Illuminance of 1 footcandle");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_FOOTCANDLE,'g',15);
 	m_constantsUnits << "cd sr / m^2";
 	m_constantsNames << i18n("Luminance of 1 lambert");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_LAMBERT,'g',15);
 	m_constantsUnits << "cd sr / m^2";
 	m_constantsNames << i18n("Luminance of 1 footlambert");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_FOOTLAMBERT,'g',15);
 	m_constantsUnits << "cd sr / m^2";
 
 	for (int i = 0; i < 7; i++)
 		m_constantsGroupIndex << 13;
 
 	// Radioactivity
 	m_constantsNames << i18n("Activity of 1 curie");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_CURIE,'g',15);
 	m_constantsUnits << "1 / s";
 	m_constantsNames << i18n("Exposure of 1 roentgen");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ROENTGEN,'g',15);
 	m_constantsUnits << "A s / kg";
 	m_constantsNames << i18n("Absorbed dose of 1 rad");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_RAD,'g',15);
 	m_constantsUnits << "m^2 / s^2";
 
 	for (int i = 0; i < 3; i++)
 		m_constantsGroupIndex << 14;
 
 	// Force and Energy
 	m_constantsNames << i18n("SI unit of force");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_NEWTON,'g',15);
 	m_constantsUnits << "kg m / s^2";
 	m_constantsNames << i18n("Force of 1 Dyne");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_DYNE,'g',15);
 	m_constantsUnits << "kg m / s^2";
 	m_constantsNames << i18n("SI unit of energy");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_JOULE,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 	m_constantsNames << i18n("Energy 1 erg");
 	m_constantsValues << QString::number(GSL_CONST_MKSA_ERG,'g',15);
 	m_constantsUnits << "kg m^2 / s^2";
 
 	for (int i = 0; i < 4; i++)
 		m_constantsGroupIndex << 15;
 }
 
 ExpressionParser::~ExpressionParser() {
 	delete_table();
 }
 
 ExpressionParser* ExpressionParser::getInstance() {
 	if (!instance)
 		instance = new ExpressionParser();
 
 	return instance;
 }
 
 const QStringList& ExpressionParser::functions() {
 	return m_functions;
 }
 
 
 const QStringList& ExpressionParser::functionsGroups() {
 	return m_functionsGroups;
 }
 
 const QStringList& ExpressionParser::functionsNames() {
 	return m_functionsNames;
 }
 
 const QVector<int>& ExpressionParser::functionsGroupIndices() {
 	return m_functionsGroupIndex;
 }
 
 const QStringList& ExpressionParser::constants() {
 	return m_constants;
 }
 
 const QStringList& ExpressionParser::constantsGroups() {
 	return m_constantsGroups;
 }
 
 const QStringList& ExpressionParser::constantsNames() {
 	return m_constantsNames;
 }
 
 const QStringList& ExpressionParser::constantsValues() {
 	return m_constantsValues;
 }
 
 const QStringList& ExpressionParser::constantsUnits() {
 	return m_constantsUnits;
 }
 
 const QVector<int>& ExpressionParser::constantsGroupIndices() {
 	return m_constantsGroupIndex;
 }
 
 bool ExpressionParser::isValid(const QString& expr, const QStringList& vars) {
 	for (int i = 0; i < vars.size(); ++i) {
 		QByteArray varba = vars.at(i).toLatin1();
 		assign_variable(varba.constData(), 0);
 	}
 
 	QByteArray funcba = expr.toLatin1();
 	const char* data = funcba.constData();
 
 	gsl_set_error_handler_off();
 	parse(data);
 	return !(parse_errors() > 0);
 }
 
 QStringList ExpressionParser::getParameter(const QString& expr, const QStringList& vars) {
 	DEBUG("ExpressionParser::getParameter()");
 	QDEBUG("variables:" << vars);
 	QStringList parameters;
 
 	QStringList strings = expr.split(QRegExp("\\W+"), QString::SkipEmptyParts);
 	QDEBUG("found strings:" << strings);
 	for (int i = 0; i < strings.size(); ++i) {
 		// check if token is not a known constant/function/variable or number
 		if (constants().indexOf(strings[i]) == -1 && functions().indexOf(strings[i]) == -1
 		        && vars.indexOf(strings[i]) == -1 && QRegExp("[0-9]*").exactMatch(strings[i]) == 0)
 			parameters << strings[i];
 		else
 			QDEBUG(strings[i] << ':' << constants().indexOf(strings[i]) << ' ' << functions().indexOf(strings[i]) << ' '
 			       << vars.indexOf(strings[i]) << ' ' << QRegExp("[0-9]*").exactMatch(strings[i]));
 	}
 	parameters.removeDuplicates();
 	QDEBUG("parameters found:" << parameters);
 
 	return parameters;
 }
 
 bool ExpressionParser::evaluateCartesian(const QString& expr, const QString& min, const QString& max,
         int count, QVector<double>* xVector, QVector<double>* yVector,
         const QStringList& paramNames, const QVector<double>& paramValues) {
 
 	QByteArray xminba = min.toLatin1();
 	const double xMin = parse(xminba.constData());
 
 	QByteArray xmaxba = max.toLatin1();
 	const double xMax = parse(xmaxba.constData());
 
 	const double step = (xMax - xMin)/(double)(count - 1);
 
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double x, y;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < paramNames.size(); ++i) {
 		QByteArray paramba = paramNames.at(i).toLatin1();
 		assign_variable(paramba.constData(), paramValues.at(i));
 	}
 
 	for (int i = 0; i < count; i++) {
 		x = xMin + step * i;
 		assign_variable("x", x);
 		y = parse(func);
 
 		if (parse_errors() > 0)
 			return false;
 
 		(*xVector)[i] = x;
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
 
 bool ExpressionParser::evaluateCartesian(const QString& expr, const QString& min, const QString& max,
         int count, QVector<double>* xVector, QVector<double>* yVector) {
 
 	QByteArray xminba = min.toLatin1();
 	const double xMin = parse(xminba.constData());
 
 	QByteArray xmaxba = max.toLatin1();
 	const double xMax = parse(xmaxba.constData());
 
 	const double step = (xMax - xMin)/(double)(count - 1);
 
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double x, y;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < count; i++) {
 		x = xMin + step*i;
 		assign_variable("x", x);
 		y = parse(func);
 
 		if (parse_errors() > 0)
 			return false;
 
 		(*xVector)[i] = x;
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
 
 bool ExpressionParser::evaluateCartesian(const QString& expr, QVector<double>* xVector, QVector<double>* yVector) {
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double x, y;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < xVector->count(); i++) {
 		x = xVector->at(i);
 		assign_variable("x", x);
 		y = parse(func);
 
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
 
 bool ExpressionParser::evaluateCartesian(const QString& expr, QVector<double>* xVector, QVector<double>* yVector,
         const QStringList& paramNames, const QVector<double>& paramValues) {
 
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double x, y;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < paramNames.size(); ++i) {
 		QByteArray paramba = paramNames.at(i).toLatin1();
 		assign_variable(paramba.constData(), paramValues.at(i));
 	}
 
 	for (int i = 0; i < xVector->count(); i++) {
 		x = xVector->at(i);
 		assign_variable("x", x);
 		y = parse(func);
 
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
 
 /*!
 	evaluates multivariate function y=f(x_1, x_2, ...).
 	Variable names (x_1, x_2, ...) are stored in \c vars.
 	Data is stored in \c dataVectors.
  */
 bool ExpressionParser::evaluateCartesian(const QString& expr, const QStringList& vars, const QVector<QVector<double>*>& xVectors, QVector<double>* yVector) {
 	Q_ASSERT(vars.size() == xVectors.size());
 
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double y, varValue;
 	QString varName;
 
 	gsl_set_error_handler_off();
 
 	bool stop = false;
 	for (int i = 0; i < yVector->size(); i++) {
 		//stop iterating over i if one of the x-vectors has no elements anymore.
-		for (auto xVector: xVectors) {
+		for (auto* xVector : xVectors) {
 			if (i == xVector->size()) {
 				stop = true;
 				break;
 			}
 		}
 		if (stop)
 			break;
 
 		for (int n = 0; n < vars.size(); ++n) {
 			varName = vars.at(n);
 			varValue = xVectors.at(n)->at(i);
 			QByteArray varba = varName.toLatin1();
 			assign_variable(varba.constData(), varValue);
 		}
 
 		y = parse(func);
 
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
 
 bool ExpressionParser::evaluatePolar(const QString& expr, const QString& min, const QString& max,
                                      int count, QVector<double>* xVector, QVector<double>* yVector) {
 
 	QByteArray minba = min.toLatin1();
 	const double minValue = parse(minba.constData());
 
 	QByteArray maxba = max.toLatin1();
 	const double maxValue = parse(maxba.constData());
 
 	const double step = (maxValue - minValue)/(double)(count - 1);
 
 	QByteArray funcba = expr.toLatin1();
 	const char* func = funcba.constData();
 
 	double r, phi;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < count; i++) {
 		phi = minValue + step * i;
 		assign_variable("phi", phi);
 		r = parse(func);
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(r)) {
 			(*xVector)[i] = r*cos(phi);
 			(*yVector)[i] = r*sin(phi);
 		} else {
 			(*xVector)[i] = NAN;
 			(*yVector)[i] = NAN;
 		}
 	}
 
 	return true;
 }
 
 bool ExpressionParser::evaluateParametric(const QString& expr1, const QString& expr2, const QString& min, const QString& max,
         int count, QVector<double>* xVector, QVector<double>* yVector) {
 
 	QByteArray minba = min.toLatin1();
 	const double minValue = parse(minba.constData());
 
 	QByteArray maxba = max.toLatin1();
 	const double maxValue = parse(maxba.constData());
 
 	const double step = (maxValue - minValue)/(double)(count - 1);
 
 	QByteArray xfuncba = expr1.toLatin1();
 	const char* xFunc = xfuncba.constData();
 
 	QByteArray yfuncba = expr2.toLatin1();
 	const char* yFunc = yfuncba.constData();
 
 	double x, y, t;
 	gsl_set_error_handler_off();
 
 	for (int i = 0; i < count; i++) {
 		t = minValue + step*i;
 		assign_variable("t", t);
 		x = parse(xFunc);
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(x))
 			(*xVector)[i] = x;
 		else
 			(*xVector)[i] = NAN;
 
 		y = parse(yFunc);
 		if (parse_errors() > 0)
 			return false;
 
 		if (std::isfinite(y))
 			(*yVector)[i] = y;
 		else
 			(*yVector)[i] = NAN;
 	}
 
 	return true;
 }
diff --git a/src/backend/spreadsheet/Spreadsheet.cpp b/src/backend/spreadsheet/Spreadsheet.cpp
index f248a45d4..5893e7b12 100644
--- a/src/backend/spreadsheet/Spreadsheet.cpp
+++ b/src/backend/spreadsheet/Spreadsheet.cpp
@@ -1,944 +1,944 @@
 /***************************************************************************
     File                 : Spreadsheet.cpp
     Project              : LabPlot
     Description          : Aspect providing a spreadsheet table with column logic
     --------------------------------------------------------------------
     Copyright            : (C) 2006-2008 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2006-2009 Knut Franke (knut.franke@gmx.de)
     Copyright            : (C) 2012-2017 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2017 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 "Spreadsheet.h"
 #include "backend/core/AspectPrivate.h"
 #include "backend/core/AbstractAspect.h"
 #include "backend/core/column/ColumnStringIO.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
 
 #include <QIcon>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <algorithm>
 
 /*!
   \class Spreadsheet
   \brief Aspect providing a spreadsheet table with column logic.
 
   Spreadsheet is a container object for columns with no data of its own. By definition, it's columns
   are all of its children inheriting from class Column. Thus, the basic API is already defined
   by AbstractAspect (managing the list of columns, notification of column insertion/removal)
   and Column (changing and monitoring state of the actual data).
 
   Spreadsheet stores a pointer to its primary view of class SpreadsheetView. SpreadsheetView calls the Spreadsheet
   API but Spreadsheet only notifies SpreadsheetView by signals without calling its API directly. This ensures a
   maximum independence of UI and backend. SpreadsheetView can be easily replaced by a different class.
   User interaction is completely handled in SpreadsheetView and translated into
   Spreadsheet API calls (e.g., when a user edits a cell this will be handled by the delegate of
   SpreadsheetView and Spreadsheet will not know whether a script or a user changed the data.). All actions,
   menus etc. for the user interaction are handled SpreadsheetView, e.g., via a context menu.
   Selections are also handled by SpreadsheetView. The view itself is created by the first call to view();
 
   \ingroup backend
 */
 
 Spreadsheet::Spreadsheet(const QString& name, bool loading) : AbstractDataSource(name), m_view(nullptr) {
 
 	if (!loading)
 		init();
 }
 
 /*!
 	initializes the spreadsheet with the default number of columns and rows
 */
 void Spreadsheet::init() {
 	KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Spreadsheet"));
 	const int columns = group.readEntry(QLatin1String("ColumnCount"), 2);
 	const int rows = group.readEntry(QLatin1String("RowCount"), 100);
 
 	for (int i = 0; i < columns; i++) {
 		Column* new_col = new Column(QString::number(i+1), AbstractColumn::Numeric);
 		new_col->setPlotDesignation(i == 0 ? AbstractColumn::X : AbstractColumn::Y);
 		addChild(new_col);
 	}
 	setRowCount(rows);
 }
 
 /*! Constructs a primary view on me.
   This method may be called multiple times during the life time of an Aspect, or it might not get
   called at all. Aspects must not depend on the existence of a view for their operation.
 */
 QWidget* Spreadsheet::view() const {
 	if (!m_partView) {
 		m_view = new SpreadsheetView(const_cast<Spreadsheet*>(this));
 		m_partView = m_view;
 	}
 	return m_partView;
 }
 
 bool Spreadsheet::exportView() const {
 	return m_view->exportView();
 }
 
 bool Spreadsheet::printView() {
 	return m_view->printView();
 }
 
 bool Spreadsheet::printPreview() const {
 	return m_view->printPreview();
 }
 
 /*!
   Returns the maximum number of rows in the spreadsheet.
  */
 int Spreadsheet::rowCount() const {
 	int col_rows, result = 0;
-	for (auto* col: children<Column>())
+	for (auto* col : children<Column>())
 		if ((col_rows = col->rowCount()) > result)
 			result = col_rows;
 	return result;
 }
 
 void Spreadsheet::removeRows(int first, int count) {
 	if( count < 1 || first < 0 || first+count > rowCount()) return;
 	WAIT_CURSOR;
 	beginMacro( i18np("%1: remove 1 row", "%1: remove %2 rows", name(), count) );
-	for (auto* col: children<Column>(IncludeHidden))
+	for (auto* col : children<Column>(IncludeHidden))
 		col->removeRows(first, count);
 	endMacro();
 	RESET_CURSOR;
 }
 
 void Spreadsheet::insertRows(int before, int count) {
 	if( count < 1 || before < 0 || before > rowCount()) return;
 	WAIT_CURSOR;
 	beginMacro( i18np("%1: insert 1 row", "%1: insert %2 rows", name(), count) );
-	for (auto* col: children<Column>(IncludeHidden))
+	for (auto* col : children<Column>(IncludeHidden))
 		col->insertRows(before, count);
 	endMacro();
 	RESET_CURSOR;
 }
 
 void Spreadsheet::appendRows(int count) {
 	insertRows(rowCount(), count);
 }
 
 void Spreadsheet::appendRow() {
 	insertRows(rowCount(), 1);
 }
 
 void Spreadsheet::appendColumns(int count) {
 	insertColumns(columnCount(), count);
 }
 
 void Spreadsheet::appendColumn() {
 	insertColumns(columnCount(), 1);
 }
 
 void Spreadsheet::prependColumns(int count) {
 	insertColumns(0, count);
 }
 
 /*!
   Sets the number of rows of the spreadsheet to \c new_size
 */
 void Spreadsheet::setRowCount(int new_size) {
 	int current_size = rowCount();
 	if (new_size > current_size)
 		insertRows(current_size, new_size-current_size);
 	if (new_size < current_size && new_size >= 0)
 		removeRows(new_size, current_size-new_size);
 }
 
 /*!
   Returns the column with the number \c index.
   Shallow wrapper around \sa AbstractAspect::child() - see there for caveat.
 */
 Column* Spreadsheet::column(int index) const {
 	return child<Column>(index);
 }
 
 
 /*!
   Returns the column with the name \c name.
 */
 Column* Spreadsheet::column(const QString &name) const {
 	return child<Column>(name);
 }
 
 /*!
   Returns the total number of columns in the spreadsheet.
 */
 int Spreadsheet::columnCount() const {
 	return childCount<Column>();
 }
 
 /*!
   Returns the number of columns matching the given designation.
  */
 int Spreadsheet::columnCount(AbstractColumn::PlotDesignation pd) const {
 	int count = 0;
-	for (auto* col: children<Column>())
+	for (auto* col : children<Column>())
 		if (col->plotDesignation() == pd)
 			count++;
 	return count;
 }
 
 void Spreadsheet::removeColumns(int first, int count) {
 	if( count < 1 || first < 0 || first+count > columnCount()) return;
 	WAIT_CURSOR;
 	beginMacro( i18np("%1: remove 1 column", "%1: remove %2 columns", name(), count) );
 	for (int i = 0; i < count; i++)
 		child<Column>(first)->remove();
 	endMacro();
 	RESET_CURSOR;
 }
 
 void Spreadsheet::insertColumns(int before, int count) {
 	WAIT_CURSOR;
 	beginMacro( i18np("%1: insert 1 column", "%1: insert %2 columns", name(), count) );
 	Column * before_col = column(before);
 	int rows = rowCount();
 	for (int i = 0; i < count; i++) {
 		Column * new_col = new Column(QString::number(i+1), AbstractColumn::Numeric);
 		new_col->setPlotDesignation(AbstractColumn::Y);
 		new_col->insertRows(0, rows);
 		insertChildBefore(new_col, before_col);
 	}
 	endMacro();
 	RESET_CURSOR;
 }
 /*!
   Sets the number of columns to \c new_size
 */
 void Spreadsheet::setColumnCount(int new_size) {
 	int old_size = columnCount();
 	if ( old_size == new_size || new_size < 0 )
 		return;
 
 	if (new_size < old_size)
 		removeColumns(new_size, old_size-new_size);
 	else
 		insertColumns(old_size, new_size-old_size);
 }
 
 /*!
   Clears the whole spreadsheet.
 */
 void Spreadsheet::clear() {
 	WAIT_CURSOR;
 	beginMacro(i18n("%1: clear", name()));
-	for (auto* col: children<Column>())
+	for (auto* col : children<Column>())
 		col->clear();
 	endMacro();
 	RESET_CURSOR;
 }
 
 /*!
   Clears all mask in the spreadsheet.
 */
 void Spreadsheet::clearMasks() {
 	WAIT_CURSOR;
 	beginMacro(i18n("%1: clear all masks", name()));
-	for (auto* col: children<Column>())
+	for (auto* col : children<Column>())
 		col->clearMasks();
 	endMacro();
 	RESET_CURSOR;
 }
 
 /*!
   Returns a new context menu. The caller takes ownership of the menu.
 */
 QMenu* Spreadsheet::createContextMenu() {
 	QMenu* menu = AbstractPart::createContextMenu();
 	Q_ASSERT(menu);
 	emit requestProjectContextMenu(menu);
 	return menu;
 }
 
 void Spreadsheet::moveColumn(int from, int to) {
 	Column* col = child<Column>(from);
 	beginMacro(i18n("%1: move column %2 from position %3 to %4.", name(), col->name(), from+1, to+1));
 	col->remove();
 	insertChildBefore(col, child<Column>(to));
 	endMacro();
 }
 
 void Spreadsheet::copy(Spreadsheet* other) {
 	WAIT_CURSOR;
 	beginMacro(i18n("%1: copy %2", name(), other->name()));
 
-	for (auto* col: children<Column>())
+	for (auto* col : children<Column>())
 		col->remove();
-	for (auto* src_col: other->children<Column>()) {
+	for (auto* src_col : other->children<Column>()) {
 		Column * new_col = new Column(src_col->name(), src_col->columnMode());
 		new_col->copy(src_col);
 		new_col->setPlotDesignation(src_col->plotDesignation());
 		QVector< Interval<int> > masks = src_col->maskedIntervals();
-		for (const auto& iv: masks)
+		for (const auto& iv : masks)
 			new_col->setMasked(iv);
 		QVector< Interval<int> > formulas = src_col->formulaIntervals();
-		for (const auto& iv: formulas)
+		for (const auto& iv : formulas)
 			new_col->setFormula(iv, src_col->formula(iv.start()));
 		new_col->setWidth(src_col->width());
 		addChild(new_col);
 	}
 	setComment(other->comment());
 
 	endMacro();
 	RESET_CURSOR;
 }
 
 // FIXME: replace index-based API with Column*-based one
 /*!
   Determines the corresponding X column.
 */
 int Spreadsheet::colX(int col) {
 	for(int i = col-1; i >= 0; i--) {
 		if (column(i)->plotDesignation() == AbstractColumn::X)
 			return i;
 	}
 	int cols = columnCount();
 	for(int i = col+1; i < cols; i++) {
 		if (column(i)->plotDesignation() == AbstractColumn::X)
 			return i;
 	}
 	return -1;
 }
 
 /*!
   Determines the corresponding Y column.
 */
 int Spreadsheet::colY(int col) {
 	int cols = columnCount();
 
 	if (column(col)->plotDesignation() == AbstractColumn::XError ||
 	        column(col)->plotDesignation() == AbstractColumn::YError) {
 		// look to the left first
 		for(int i=col-1; i>=0; i--) {
 			if (column(i)->plotDesignation() == AbstractColumn::Y)
 				return i;
 		}
 		for(int i=col+1; i<cols; i++) {
 			if (column(i)->plotDesignation() == AbstractColumn::Y)
 				return i;
 		}
 	} else {
 		// look to the right first
 		for(int i=col+1; i<cols; i++) {
 			if (column(i)->plotDesignation() == AbstractColumn::Y)
 				return i;
 		}
 		for(int i=col-1; i>=0; i--) {
 			if (column(i)->plotDesignation() == AbstractColumn::Y)
 				return i;
 		}
 	}
 	return -1;
 }
 
 /*! Sorts the given list of column.
   If 'leading' is a null pointer, each column is sorted separately.
 */
 void Spreadsheet::sortColumns(Column* leading, QVector<Column*> cols, bool ascending) {
 	if(cols.isEmpty()) return;
 
 	// the normal QPair comparison does not work properly with descending sorting
 	// therefore we use our own compare functions
 	class CompareFunctions {
 	public:
 		static bool doubleLess(const QPair<double, int>& a, const QPair<double, int>& b) {
 			return a.first < b.first;
 		}
 		static bool doubleGreater(const QPair<double, int>& a, const QPair<double, int>& b) {
 			return a.first > b.first;
 		}
 		static bool integerLess(const QPair<int, int>& a, const QPair<int, int>& b) {
 			return a.first < b.first;
 		}
 		static bool integerGreater(const QPair<int, int>& a, const QPair<int, int>& b) {
 			return a.first > b.first;
 		}
 		static bool QStringLess(const QPair<QString, int>& a, const QPair<QString, int>& b) {
 			return a < b;
 		}
 		static bool QStringGreater(const QPair<QString, int>& a, const QPair<QString, int>& b) {
 			return a > b;
 		}
 		static bool QDateTimeLess(const QPair<QDateTime, int>& a, const QPair<QDateTime, int>& b) {
 			return a < b;
 		}
 		static bool QDateTimeGreater(const QPair<QDateTime, int>& a, const QPair<QDateTime, int>& b) {
 			return a > b;
 		}
 	};
 
 	WAIT_CURSOR;
 	beginMacro(i18n("%1: sort columns", name()));
 
 	if(leading == nullptr) { // sort separately
-		for (auto* col: cols) {
+		for (auto* col : cols) {
 			switch (col->columnMode()) {
 			case AbstractColumn::Numeric: {
 					int rows = col->rowCount();
 					QVector< QPair<double, int> > map;
 
-					for(int j=0; j<rows; j++)
+					for(int j = 0; j < rows; j++)
 						map.append(QPair<double, int>(col->valueAt(j), j));
 
 					if(ascending)
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleLess);
 					else
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleGreater);
 
 					QVectorIterator< QPair<double, int> > it(map);
 					Column *temp_col = new Column("temp", col->columnMode());
 
-					int k=0;
+					int k = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, k, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						k++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 					break;
 				}
 			case AbstractColumn::Integer: {
 					int rows = col->rowCount();
 					QVector< QPair<int, int> > map;
 
 					for (int j = 0; j < rows; j++)
 						map.append(QPair<int, int>(col->valueAt(j), j));
 
 					if (ascending)
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleLess);
 					else
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleGreater);
 
 					QVectorIterator<QPair<int, int>> it(map);
 					Column* temp_col = new Column("temp", col->columnMode());
 
 					int k = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, k, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						k++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 					break;
 				}
 			case AbstractColumn::Text: {
 					int rows = col->rowCount();
 					QVector<QPair<QString, int>> map;
 
 					for (int j = 0; j < rows; j++)
 						map.append(QPair<QString, int>(col->textAt(j), j));
 
 					if (ascending)
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::QStringLess);
 					else
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::QStringGreater);
 
 					QVectorIterator< QPair<QString, int> > it(map);
 					Column* temp_col = new Column("temp", col->columnMode());
 
 					int k = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, k, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						k++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 					break;
 				}
 			case AbstractColumn::DateTime:
 			case AbstractColumn::Month:
 			case AbstractColumn::Day: {
 					int rows = col->rowCount();
 					QVector< QPair<QDateTime, int> > map;
 
 					for(int j=0; j<rows; j++)
 						map.append(QPair<QDateTime, int>(col->dateTimeAt(j), j));
 
 					if(ascending)
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::QDateTimeLess);
 					else
 						std::stable_sort(map.begin(), map.end(), CompareFunctions::QDateTimeGreater);
 
 					QVectorIterator< QPair<QDateTime, int> > it(map);
 					Column *temp_col = new Column("temp", col->columnMode());
 
 					int k=0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, k, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						k++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 					break;
 				}
 			}
 		}
 	} else { // sort with leading column
 		switch (leading->columnMode()) {
 		case AbstractColumn::Numeric: {
 				QVector<QPair<double, int>> map;
 				int rows = leading->rowCount();
 
 				for (int i = 0; i < rows; i++)
 					map.append(QPair<double, int>(leading->valueAt(i), i));
 
 				if (ascending)
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleLess);
 				else
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::doubleGreater);
 				QVectorIterator<QPair<double, int>> it(map);
 
-				for (auto* col: cols) {
+				for (auto* col : cols) {
 					Column *temp_col = new Column("temp", col->columnMode());
 					it.toFront();
 					int j = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, j, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						j++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 				}
 				break;
 			}
 		case AbstractColumn::Integer: {
 				QVector<QPair<int, int>> map;
 				int rows = leading->rowCount();
 
 				for (int i = 0; i < rows; i++)
 					map.append(QPair<int, int>(leading->valueAt(i), i));
 
 				if (ascending)
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::integerLess);
 				else
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::integerGreater);
 				QVectorIterator<QPair<int, int>> it(map);
 
-				for (auto* col: cols) {
+				for (auto* col : cols) {
 					Column *temp_col = new Column("temp", col->columnMode());
 					it.toFront();
 					int j = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, j, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						j++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 				}
 				break;
 			}
 		case AbstractColumn::Text: {
 				QVector<QPair<QString, int>> map;
 				int rows = leading->rowCount();
 
 				for (int i = 0; i < rows; i++)
 					map.append(QPair<QString, int>(leading->textAt(i), i));
 
 				if(ascending)
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::QStringLess);
 				else
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::QStringGreater);
 				QVectorIterator<QPair<QString, int>> it(map);
 
-				for (auto* col: cols) {
+				for (auto* col : cols) {
 					Column *temp_col = new Column("temp", col->columnMode());
 					it.toFront();
 					int j = 0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, j, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						j++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 				}
 				break;
 			}
 		case AbstractColumn::DateTime:
 		case AbstractColumn::Month:
 		case AbstractColumn::Day: {
 				QVector<QPair<QDateTime, int>> map;
 				int rows = leading->rowCount();
 
 				for (int i = 0; i < rows; i++)
 					map.append(QPair<QDateTime, int>(leading->dateTimeAt(i), i));
 
 				if (ascending)
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::QDateTimeLess);
 				else
 					std::stable_sort(map.begin(), map.end(), CompareFunctions::QDateTimeGreater);
 				QVectorIterator<QPair<QDateTime, int>> it(map);
 
-				for (auto* col: cols) {
+				for (auto* col : cols) {
 					Column *temp_col = new Column("temp", col->columnMode());
 					it.toFront();
 					int j=0;
 					// put the values in the right order into temp_col
 					while(it.hasNext()) {
 						temp_col->copy(col, it.peekNext().second, j, 1);
 						temp_col->setMasked(col->isMasked(it.next().second));
 						j++;
 					}
 					// copy the sorted column
 					col->copy(temp_col, 0, 0, rows);
 					delete temp_col;
 				}
 				break;
 			}
 		}
 	}
 	endMacro();
 	RESET_CURSOR;
 } // end of sortColumns()
 
 /*!
   Returns an icon to be used for decorating my views.
   */
 QIcon Spreadsheet::icon() const {
 	return QIcon::fromTheme("labplot-spreadsheet");
 }
 
 /*!
   Returns the text displayed in the given cell.
 */
 QString Spreadsheet::text(int row, int col) const {
 	Column* c = column(col);
 	if(!c)
 		return QString();
 
 	return c->asStringColumn()->textAt(row);
 }
 
 /*!
  * This slot is, indirectly, called when a child of \c Spreadsheet (i.e. column) was selected in \c ProjectExplorer.
  * Emits the signal \c columnSelected that is handled in \c SpreadsheetView.
  */
 void Spreadsheet::childSelected(const AbstractAspect* aspect) {
 	const Column* column = qobject_cast<const Column*>(aspect);
 	if (column) {
 		int index = indexOfChild<Column>(column);
 		emit columnSelected(index);
 	}
 }
 
 /*!
  * This slot is, indirectly, called when a child of \c Spreadsheet (i.e. column) was deselected in \c ProjectExplorer.
  * Emits the signal \c columnDeselected that is handled in \c SpreadsheetView.
  */
 void Spreadsheet::childDeselected(const AbstractAspect* aspect) {
 	const Column* column = qobject_cast<const Column*>(aspect);
 	if (column) {
 		int index = indexOfChild<Column>(column);
 		emit columnDeselected(index);
 	}
 }
 
 /*!
  *  Emits the signal to select or to deselect the column number \c index in the project explorer,
  *  if \c selected=true or \c selected=false, respectively.
  *  The signal is handled in \c AspectTreeModel and forwarded to the tree view in \c ProjectExplorer.
  * This function is called in \c SpreadsheetView upon selection changes.
  */
 void Spreadsheet::setColumnSelectedInView(int index, bool selected) {
 	if (selected) {
 		emit childAspectSelectedInView(child<Column>(index));
 
 		//deselect the spreadsheet in the project explorer, if a child (column) was selected.
 		//prevents unwanted multiple selection with spreadsheet (if it was selected before).
 		emit childAspectDeselectedInView(this);
 	} else
 		emit childAspectDeselectedInView(child<Column>(index));
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 /*!
   Saves as XML.
  */
 void Spreadsheet::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("spreadsheet");
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//columns
-	for (auto* col: children<Column>(IncludeHidden))
+	for (auto* col : children<Column>(IncludeHidden))
 		col->save(writer);
 
 	writer->writeEndElement(); // "spreadsheet"
 }
 
 /*!
   Loads from XML.
 */
 bool Spreadsheet::load(XmlStreamReader* reader, bool preview) {
 	if (!readBasicAttributes(reader))
 		return false;
 
 	// read child elements
 	while (!reader->atEnd()) {
 		reader->readNext();
 
 		if (reader->isEndElement()) break;
 
 		if (reader->isStartElement()) {
 			if (reader->name() == "comment") {
 				if (!readCommentElement(reader)) return false;
 			} else if(reader->name() == "column") {
 				Column* column = new Column("");
 				if (!column->load(reader, preview)) {
 					delete column;
 					setColumnCount(0);
 					return false;
 				}
 				addChildFast(column);
 			} else {	// unknown element
 				reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 				if (!reader->skipToEndElement()) return false;
 			}
 		}
 	}
 
 	return !reader->hasError();
 }
 
 
 //##############################################################################
 //########################  Data Import  #######################################
 //##############################################################################
 int Spreadsheet::prepareImport(QVector<void*>& dataContainer, AbstractFileFilter::ImportMode importMode,
                                int actualRows, int actualCols, QStringList colNameList, QVector<AbstractColumn::ColumnMode> columnMode) {
 	DEBUG("Spreadsheet::prepareImport()");
 	DEBUG("	resize spreadsheet to rows = " << actualRows << " and cols = " << actualCols);
 	int columnOffset = 0;
 	setUndoAware(false);
 
 	//make the available columns undo unaware before we resize and rename them below,
 	//the same will be done for new columns in this->resize().
 	for (int i = 0; i < childCount<Column>(); i++)
 		child<Column>(i)->setUndoAware(false);
 
 	columnOffset = this->resize(importMode, colNameList, actualCols);
 
 	// resize the spreadsheet
 	if (importMode == AbstractFileFilter::Replace) {
 		clear();
 		setRowCount(actualRows);
 	}  else {
 		if (rowCount() < actualRows)
 			setRowCount(actualRows);
 	}
 
 	if (columnMode.size() < actualCols) {
 		qWarning("columnMode[] size is too small! Giving up.");
 		return -1;
 	}
 
 	dataContainer.resize(actualCols);
 	for (int n = 0; n < actualCols; n++) {
 		// data() returns a void* which is a pointer to any data type (see ColumnPrivate.cpp)
 		Column* column = this->child<Column>(columnOffset+n);
 		DEBUG(" column " << n << " columnMode = " << columnMode[n]);
 		column->setColumnMode(columnMode[n]);
 
 		//in the most cases the first imported column is meant to be used as x-data.
 		//Other columns provide mostly y-data or errors.
 		//TODO: this has to be configurable for the user in the import widget,
 		//it should be possible to specify x-error plot designation, etc.
 		AbstractColumn::PlotDesignation desig =  (n == 0) ? AbstractColumn::X : AbstractColumn::Y;
 		column->setPlotDesignation(desig);
 
 		switch (columnMode[n]) {
 		case AbstractColumn::Numeric: {
 			QVector<double>* vector = static_cast<QVector<double>*>(column->data());
 			vector->resize(actualRows);
 			dataContainer[n] = static_cast<void*>(vector);
 			break;
 		}
 		case AbstractColumn::Integer: {
 			QVector<int>* vector = static_cast<QVector<int>*>(column->data());
 			vector->resize(actualRows);
 			dataContainer[n] = static_cast<void*>(vector);
 			break;
 		}
 		case AbstractColumn::Text: {
 			QVector<QString>* vector = static_cast<QVector<QString>*>(column->data());
 			vector->resize(actualRows);
 			dataContainer[n] = static_cast<void*>(vector);
 			break;
 		}
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 		case AbstractColumn::DateTime: {
 			QVector<QDateTime>* vector = static_cast<QVector<QDateTime>* >(column->data());
 			vector->resize(actualRows);
 			dataContainer[n] = static_cast<void*>(vector);
 			break;
 		}
 		}
 	}
 //	QDEBUG("dataPointers =" << dataPointers);
 
 	DEBUG("Spreadsheet::prepareImport() DONE");
 
 	return columnOffset;
 }
 
 /*!
 	resize data source to cols columns
 	returns column offset depending on import mode
 */
 int Spreadsheet::resize(AbstractFileFilter::ImportMode mode, QStringList colNameList, int cols) {
 	// name additional columns
 	for (int k = colNameList.size(); k < cols; k++ )
 		colNameList.append( "Column " + QString::number(k+1) );
 
 	int columnOffset = 0; //indexes the "start column" in the spreadsheet. Starting from this column the data will be imported.
 
 	Column* newColumn = nullptr;
 	if (mode == AbstractFileFilter::Append) {
 		columnOffset = childCount<Column>();
 		for (int n = 0; n < cols; n++ ) {
 			newColumn = new Column(colNameList.at(n), AbstractColumn::Numeric);
 			newColumn->setUndoAware(false);
 			addChildFast(newColumn);
 		}
 	} else if (mode == AbstractFileFilter::Prepend) {
 		Column* firstColumn = child<Column>(0);
 		for (int n = 0; n < cols; n++ ) {
 			newColumn = new Column(colNameList.at(n), AbstractColumn::Numeric);
 			newColumn->setUndoAware(false);
 			insertChildBeforeFast(newColumn, firstColumn);
 		}
 	} else if (mode == AbstractFileFilter::Replace) {
 		//replace completely the previous content of the data source with the content to be imported.
 		int columns = childCount<Column>();
 
 		if (columns > cols) {
 			//there're more columns in the data source then required -> remove the superfluous columns
 			for (int i = 0; i < columns-cols; i++)
 				removeChild(child<Column>(0));
 		} else {
 			//create additional columns if needed
 			for (int i = columns; i < cols; i++) {
 				newColumn = new Column(colNameList.at(i), AbstractColumn::Numeric);
 				newColumn->setUndoAware(false);
 				addChildFast(newColumn);
 			}
 		}
 
 		//rename the columns that are already available and suppress the dataChanged signal for them
 		for (int i = 0; i < childCount<Column>(); i++) {
 			if (mode == AbstractFileFilter::Replace)
 				child<Column>(i)->setSuppressDataChangedSignal(true);
 
 			child<Column>(i)->setName(colNameList.at(i));
 		}
 	}
 
 	return columnOffset;
 }
 
 void Spreadsheet::finalizeImport(int columnOffset, int startColumn, int endColumn, int numRows, const QString& dateTimeFormat, AbstractFileFilter::ImportMode importMode)  {
 	DEBUG("Spreadsheet::finalizeImport()");
 
 	// shrink the spreadsheet if needed
 	if (numRows > 0 && numRows != rowCount()) {
 		if (importMode == AbstractFileFilter::Replace)
 			setRowCount(numRows);
 	}
 
 	// set the comments for each of the columns if datasource is a spreadsheet
 	const int rows = rowCount();
 	for (int n = startColumn; n <= endColumn; n++) {
 		Column* column = this->column(columnOffset + n - startColumn);
 		//DEBUG("	column " << n << " of type " << column->columnMode());
 
 		QString comment;
 		switch (column->columnMode()) {
 		case AbstractColumn::Numeric:
 			comment = i18np("numerical data, %1 element", "numerical data, %1 elements", rows);
 			break;
 		case AbstractColumn::Integer:
 			comment = i18np("integer data, %1 element", "integer data, %1 elements", rows);
 			break;
 		case AbstractColumn::Text:
 			comment = i18np("text data, %1 element", "text data, %1 elements", rows);
 			break;
 		case AbstractColumn::Month:
 			comment = i18np("month data, %1 element", "month data, %1 elements", rows);
 			break;
 		case AbstractColumn::Day:
 			comment = i18np("day data, %1 element", "day data, %1 elements", rows);
 			break;
 		case AbstractColumn::DateTime:
 			comment = i18np("date and time data, %1 element", "date and time data, %1 elements", rows);
 			// set same datetime format in column
 			DateTime2StringFilter* filter = static_cast<DateTime2StringFilter*>(column->outputFilter());
 			filter->setFormat(dateTimeFormat);
 		}
 		column->setComment(comment);
 
 		if (importMode == AbstractFileFilter::Replace) {
 			column->setSuppressDataChangedSignal(false);
 			column->setChanged();
 		}
 	}
 
 	//make the spreadsheet and all its children undo aware again
 	setUndoAware(true);
 	for (int i = 0; i < childCount<Column>(); i++)
 		child<Column>(i)->setUndoAware(true);
 
 	if (m_partView != nullptr && m_view != nullptr)
 		m_view->resizeHeader();
 
 	DEBUG("Spreadsheet::finalizeImport() DONE");
 }
diff --git a/src/backend/worksheet/plots/cartesian/Axis.cpp b/src/backend/worksheet/plots/cartesian/Axis.cpp
index 0160031d3..d044f9148 100644
--- a/src/backend/worksheet/plots/cartesian/Axis.cpp
+++ b/src/backend/worksheet/plots/cartesian/Axis.cpp
@@ -1,2211 +1,2211 @@
 /***************************************************************************
     File                 : Axis.cpp
     Project              : LabPlot
     Description          : Axis for cartesian coordinate systems.
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2013-2018 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 "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/AxisPrivate.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/worksheet/plots/cartesian/CartesianCoordinateSystem.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/core/AbstractColumn.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/macros.h"
 // #include "backend/lib/trace.h"
 #include "kdefrontend/GuiTools.h"
 
 #include <QGraphicsSceneContextMenuEvent>
 #include <QMenu>
 #include <QPainter>
 #include <QTextDocument>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 extern "C" {
 #include "backend/nsl/nsl_math.h"
 }
 
 /**
  * \class AxisGrid
  * \brief Helper class to get the axis grid drawn with the z-Value=0.
  *
  * The painting of the grid lines is separated from the painting of the axis itself.
  * This allows to use a different z-values for the grid lines (z=0, drawn below all other objects )
  * and for the axis (z=FLT_MAX, drawn on top of all other objects)
  *
  *  \ingroup worksheet
  */
 class AxisGrid : public QGraphicsItem {
 	public:
 		AxisGrid(AxisPrivate* a) {
 			axis = a;
 			setFlag(QGraphicsItem::ItemIsSelectable, false);
 			setFlag(QGraphicsItem::ItemIsFocusable, false);
 			setAcceptHoverEvents(false);
 		}
 
 		QRectF boundingRect() const override {
 			QPainterPath gridShape;
 			gridShape.addPath(WorksheetElement::shapeFromPath(axis->majorGridPath, axis->majorGridPen));
 			gridShape.addPath(WorksheetElement::shapeFromPath(axis->minorGridPath, axis->minorGridPen));
 			QRectF boundingRectangle = gridShape.boundingRect();
 			return boundingRectangle;
 		}
 
 		void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) override {
 			Q_UNUSED(option)
 			Q_UNUSED(widget)
 
 			if (!axis->isVisible()) return;
 			if (axis->linePath.isEmpty()) return;
 
 			//draw major grid
 			if (axis->majorGridPen.style() != Qt::NoPen) {
 				painter->setOpacity(axis->majorGridOpacity);
 				painter->setPen(axis->majorGridPen);
 				painter->setBrush(Qt::NoBrush);
 				painter->drawPath(axis->majorGridPath);
 			}
 
 			//draw minor grid
 			if (axis->minorGridPen.style() != Qt::NoPen) {
 				painter->setOpacity(axis->minorGridOpacity);
 				painter->setPen(axis->minorGridPen);
 				painter->setBrush(Qt::NoBrush);
 				painter->drawPath(axis->minorGridPath);
 			}
 		}
 
 	private:
 		AxisPrivate* axis;
 };
 
 /**
  * \class Axis
  * \brief Axis for cartesian coordinate systems.
  *
  *  \ingroup worksheet
  */
 Axis::Axis(const QString& name, AxisOrientation orientation)
 		: WorksheetElement(name), d_ptr(new AxisPrivate(this)), m_menusInitialized(false) {
 	d_ptr->orientation = orientation;
 	init();
 }
 
 Axis::Axis(const QString& name, AxisOrientation orientation, AxisPrivate* dd)
 		: WorksheetElement(name), d_ptr(dd), m_menusInitialized(false) {
 	d_ptr->orientation = orientation;
 	init();
 }
 
 void Axis::finalizeAdd() {
 	Q_D(Axis);
 	d->plot = dynamic_cast<CartesianPlot*>(parentAspect());
 	Q_ASSERT(d->plot);
 	d->cSystem = dynamic_cast<const CartesianCoordinateSystem*>(d->plot->coordinateSystem());
 }
 
 void Axis::init() {
 	Q_D(Axis);
 
 	KConfig config;
 	KConfigGroup group = config.group( "Axis" );
 
 	d->autoScale = true;
 	d->position = Axis::AxisCustom;
 	d->offset = group.readEntry("PositionOffset", 0);
 	d->scale = (Axis::AxisScale) group.readEntry("Scale", (int) Axis::ScaleLinear);
 	d->autoScale = group.readEntry("AutoScale", true);
 	d->start = group.readEntry("Start", 0);
 	d->end = group.readEntry("End", 10);
 	d->zeroOffset = group.readEntry("ZeroOffset", 0);
 	d->scalingFactor = group.readEntry("ScalingFactor", 1.0);
 
 	d->linePen.setStyle( (Qt::PenStyle) group.readEntry("LineStyle", (int) Qt::SolidLine) );
 	d->linePen.setWidthF( group.readEntry("LineWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->lineOpacity = group.readEntry("LineOpacity", 1.0);
 	d->arrowType = (Axis::ArrowType) group.readEntry("ArrowType", (int)Axis::NoArrow);
 	d->arrowPosition = (Axis::ArrowPosition) group.readEntry("ArrowPosition", (int)Axis::ArrowRight);
 	d->arrowSize = group.readEntry("ArrowSize", Worksheet::convertToSceneUnits(10, Worksheet::Point));
 
 	// axis title
  	d->title = new TextLabel(this->name(), TextLabel::AxisTitle);
 	connect( d->title, &TextLabel::changed, this, &Axis::labelChanged);
 	addChild(d->title);
 	d->title->setHidden(true);
 	d->title->graphicsItem()->setParentItem(graphicsItem());
 	d->title->graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 	d->title->graphicsItem()->setAcceptHoverEvents(false);
 	d->title->setText(this->name());
 	if (d->orientation == AxisVertical) d->title->setRotationAngle(90);
 	d->titleOffsetX = Worksheet::convertToSceneUnits(2, Worksheet::Point); //distance to the axis tick labels
 	d->titleOffsetY = Worksheet::convertToSceneUnits(2, Worksheet::Point); //distance to the axis tick labels
 
 	d->majorTicksDirection = (Axis::TicksDirection) group.readEntry("MajorTicksDirection", (int) Axis::ticksOut);
 	d->majorTicksType = (Axis::TicksType) group.readEntry("MajorTicksType", (int) Axis::TicksTotalNumber);
 	d->majorTicksNumber = group.readEntry("MajorTicksNumber", 11);
 	d->majorTicksIncrement = group.readEntry("MajorTicksIncrement", 1.0);
 	d->majorTicksPen.setStyle((Qt::PenStyle) group.readEntry("MajorTicksLineStyle", (int)Qt::SolidLine) );
 	d->majorTicksPen.setColor( group.readEntry("MajorTicksColor", QColor(Qt::black) ) );
 	d->majorTicksPen.setWidthF( group.readEntry("MajorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point) ) );
 	d->majorTicksLength = group.readEntry("MajorTicksLength", Worksheet::convertToSceneUnits(6.0, Worksheet::Point));
 	d->majorTicksOpacity = group.readEntry("MajorTicksOpacity", 1.0);
 
 	d->minorTicksDirection = (Axis::TicksDirection) group.readEntry("MinorTicksDirection", (int) Axis::ticksOut);
 	d->minorTicksType = (Axis::TicksType) group.readEntry("MinorTicksType", (int) Axis::TicksTotalNumber);
 	d->minorTicksNumber = group.readEntry("MinorTicksNumber", 1);
 	d->minorTicksIncrement = group.readEntry("MinorTicksIncrement", 0.5);
 	d->minorTicksPen.setStyle((Qt::PenStyle) group.readEntry("MinorTicksLineStyle", (int)Qt::SolidLine) );
 	d->minorTicksPen.setColor( group.readEntry("MinorTicksColor", QColor(Qt::black) ) );
 	d->minorTicksPen.setWidthF( group.readEntry("MinorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point) ) );
 	d->minorTicksLength = group.readEntry("MinorTicksLength", Worksheet::convertToSceneUnits(3.0, Worksheet::Point));
 	d->minorTicksOpacity = group.readEntry("MinorTicksOpacity", 1.0);
 
 	//Labels
 	d->labelsFormat = (Axis::LabelsFormat) group.readEntry("LabelsFormat", (int)Axis::FormatDecimal);
 	d->labelsAutoPrecision = group.readEntry("LabelsAutoPrecision", true);
 	d->labelsPrecision = group.readEntry("LabelsPrecision", 1);
 	d->labelsDateTimeFormat = group.readEntry("LabelsDateTimeFormat", "yyyy-MM-dd hh:mm:ss");
 	d->labelsPosition = (Axis::LabelsPosition) group.readEntry("LabelsPosition", (int) Axis::LabelsOut);
 	d->labelsOffset= group.readEntry("LabelsOffset",  Worksheet::convertToSceneUnits( 5.0, Worksheet::Point ));
 	d->labelsRotationAngle = group.readEntry("LabelsRotation", 0);
 	d->labelsFont = group.readEntry("LabelsFont", QFont());
 	d->labelsFont.setPixelSize( Worksheet::convertToSceneUnits( 10.0, Worksheet::Point ) );
 	d->labelsColor = group.readEntry("LabelsFontColor", QColor(Qt::black));
 	d->labelsPrefix =  group.readEntry("LabelsPrefix", "" );
 	d->labelsSuffix =  group.readEntry("LabelsSuffix", "" );
 	d->labelsOpacity = group.readEntry("LabelsOpacity", 1.0);
 
 	//major grid
 	d->majorGridPen.setStyle( (Qt::PenStyle) group.readEntry("MajorGridStyle", (int) Qt::NoPen) );
 	d->majorGridPen.setColor(group.readEntry("MajorGridColor", QColor(Qt::gray)) );
 	d->majorGridPen.setWidthF( group.readEntry("MajorGridWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->majorGridOpacity = group.readEntry("MajorGridOpacity", 1.0);
 
 	//minor grid
 	d->minorGridPen.setStyle( (Qt::PenStyle) group.readEntry("MinorGridStyle", (int) Qt::NoPen) );
 	d->minorGridPen.setColor(group.readEntry("MajorGridColor", QColor(Qt::gray)) );
 	d->minorGridPen.setWidthF( group.readEntry("MinorGridWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->minorGridOpacity = group.readEntry("MinorGridOpacity", 1.0);
 }
 
 /*!
  * For the most frequently edited properties, create Actions and ActionGroups for the context menu.
  * For some ActionGroups the actual actions are created in \c GuiTool,
  */
 void Axis::initActions() {
 	visibilityAction = new QAction(i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, &QAction::triggered, this, &Axis::visibilityChangedSlot);
 
 	//Orientation
 	orientationActionGroup = new QActionGroup(this);
 	orientationActionGroup->setExclusive(true);
 	connect(orientationActionGroup, &QActionGroup::triggered, this, &Axis::orientationChangedSlot);
 
 	orientationHorizontalAction = new QAction(i18n("Horizontal"), orientationActionGroup);
 	orientationHorizontalAction->setCheckable(true);
 
 	orientationVerticalAction = new QAction(i18n("Vertical"), orientationActionGroup);
 	orientationVerticalAction->setCheckable(true);
 
 	//Line
 	lineStyleActionGroup = new QActionGroup(this);
 	lineStyleActionGroup->setExclusive(true);
 	connect(lineStyleActionGroup, &QActionGroup::triggered, this, &Axis::lineStyleChanged);
 
 	lineColorActionGroup = new QActionGroup(this);
 	lineColorActionGroup->setExclusive(true);
 	connect(lineColorActionGroup, &QActionGroup::triggered, this, &Axis::lineColorChanged);
 
 	//Ticks
 	//TODO
 }
 
 void Axis::initMenus() {
 	this->initActions();
 
 	//Orientation
 	orientationMenu = new QMenu(i18n("Orientation"));
 	orientationMenu->addAction(orientationHorizontalAction);
 	orientationMenu->addAction(orientationVerticalAction);
 
 	//Line
 	lineMenu = new QMenu(i18n("Line"));
 	lineStyleMenu = new QMenu(i18n("Style"), lineMenu);
 	lineMenu->addMenu( lineStyleMenu );
 
 	lineColorMenu = new QMenu(i18n("Color"), lineMenu);
 	GuiTools::fillColorMenu( lineColorMenu, lineColorActionGroup );
 	lineMenu->addMenu( lineColorMenu );
 
 	m_menusInitialized = true;
 }
 
 QMenu* Axis::createContextMenu() {
 	if (!m_menusInitialized)
 		initMenus();
 
 	Q_D(const Axis);
 	QMenu* menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1); //skip the first action because of the "title-action"
 
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 
 	//Orientation
 	if ( d->orientation == AxisHorizontal )
 		orientationHorizontalAction->setChecked(true);
 	else
 		orientationVerticalAction->setChecked(true);
 
 	menu->insertMenu(firstAction, orientationMenu);
 
 	//Line styles
 	GuiTools::updatePenStyles( lineStyleMenu, lineStyleActionGroup, d->linePen.color() );
 	GuiTools::selectPenStyleAction(lineStyleActionGroup, d->linePen.style() );
 
 	GuiTools::selectColorAction(lineColorActionGroup, d->linePen.color() );
 
 	menu->insertMenu(firstAction, lineMenu);
 	menu->insertSeparator(firstAction);
 
 	return menu;
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon Axis::icon() const{
 	Q_D(const Axis);
 	QIcon ico;
 	if (d->orientation == Axis::AxisHorizontal)
 		ico = QIcon::fromTheme("labplot-axis-horizontal");
 	else
 		ico = QIcon::fromTheme("labplot-axis-vertical");
 
 	return ico;
 }
 
 Axis::~Axis() {
 	if (m_menusInitialized) {
 		delete orientationMenu;
 		delete lineMenu;
 	}
 
 	//no need to delete d->title, since it was added with addChild in init();
 
 	//no need to delete the d-pointer here - it inherits from QGraphicsItem
 	//and is deleted during the cleanup in QGraphicsScene
 }
 
 QGraphicsItem *Axis::graphicsItem() const {
 	return d_ptr;
 }
 
 /*!
  * overrides the implementation in WorksheetElement and sets the z-value to the maximal possible,
  * axes are drawn on top of all other object in the plot.
  */
 void Axis::setZValue(qreal) {
 	Q_D(Axis);
 	d->setZValue(std::numeric_limits<double>::max());
 	d->gridItem->setParentItem(d->parentItem());
 	d->gridItem->setZValue(0);
 }
 
 void Axis::retransform() {
 	Q_D(Axis);
 	d->retransform();
 }
 
 void Axis::retransformTickLabelStrings() {
 	Q_D(Axis);
 	d->retransformTickLabelStrings();
 }
 
 void Axis::setSuppressRetransform(bool value) {
 	Q_D(Axis);
 	d->suppressRetransform = value;
 }
 
 void Axis::handleResize(double horizontalRatio, double verticalRatio, bool pageResize) {
 // 	DEBUG("Axis::handleResize()");
 	Q_D(Axis);
 	Q_UNUSED(pageResize);
 
 	double ratio = 0;
 	if (horizontalRatio > 1.0 || verticalRatio > 1.0)
 		ratio = qMax(horizontalRatio, verticalRatio);
 	else
 		ratio = qMin(horizontalRatio, verticalRatio);
 
 	QPen pen = d->linePen;
 	pen.setWidthF(pen.widthF() * ratio);
 	d->linePen = pen;
 
 	d->majorTicksLength *= ratio; // ticks are perpendicular to axis line -> verticalRatio relevant
 	d->minorTicksLength *= ratio;
 	d->labelsFont.setPixelSize( d->labelsFont.pixelSize() * ratio ); //TODO: take into account rotated labels
 	d->labelsOffset *= ratio;
 	d->title->handleResize(horizontalRatio, verticalRatio, pageResize);
 }
 
 /* ============================ getter methods ================= */
 BASIC_SHARED_D_READER_IMPL(Axis, bool, autoScale, autoScale)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisOrientation, orientation, orientation)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisPosition, position, position)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisScale, scale, scale)
 BASIC_SHARED_D_READER_IMPL(Axis, double, offset, offset)
 BASIC_SHARED_D_READER_IMPL(Axis, double, start, start)
 BASIC_SHARED_D_READER_IMPL(Axis, double, end, end)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, scalingFactor, scalingFactor)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, zeroOffset, zeroOffset)
 
 BASIC_SHARED_D_READER_IMPL(Axis, TextLabel*, title, title)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, titleOffsetX, titleOffsetX)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, titleOffsetY, titleOffsetY)
 
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, linePen, linePen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, lineOpacity, lineOpacity)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::ArrowType, arrowType, arrowType)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::ArrowPosition, arrowPosition, arrowPosition)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, arrowSize, arrowSize)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksDirection, majorTicksDirection, majorTicksDirection)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksType, majorTicksType, majorTicksType)
 BASIC_SHARED_D_READER_IMPL(Axis, int, majorTicksNumber, majorTicksNumber)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksIncrement, majorTicksIncrement)
 BASIC_SHARED_D_READER_IMPL(Axis, const AbstractColumn*, majorTicksColumn, majorTicksColumn)
 QString& Axis::majorTicksColumnPath() const { return d_ptr->majorTicksColumnPath; }
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksLength, majorTicksLength)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, majorTicksPen, majorTicksPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksOpacity, majorTicksOpacity)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksDirection, minorTicksDirection, minorTicksDirection)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksType, minorTicksType, minorTicksType)
 BASIC_SHARED_D_READER_IMPL(Axis, int, minorTicksNumber, minorTicksNumber)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksIncrement, minorTicksIncrement)
 BASIC_SHARED_D_READER_IMPL(Axis, const AbstractColumn*, minorTicksColumn, minorTicksColumn)
 QString& Axis::minorTicksColumnPath() const { return d_ptr->minorTicksColumnPath; }
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksLength, minorTicksLength)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, minorTicksPen, minorTicksPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksOpacity, minorTicksOpacity)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::LabelsFormat, labelsFormat, labelsFormat);
 BASIC_SHARED_D_READER_IMPL(Axis, bool, labelsAutoPrecision, labelsAutoPrecision);
 BASIC_SHARED_D_READER_IMPL(Axis, int, labelsPrecision, labelsPrecision);
 BASIC_SHARED_D_READER_IMPL(Axis, QString, labelsDateTimeFormat, labelsDateTimeFormat);
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::LabelsPosition, labelsPosition, labelsPosition);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsOffset, labelsOffset);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsRotationAngle, labelsRotationAngle);
 CLASS_SHARED_D_READER_IMPL(Axis, QColor, labelsColor, labelsColor);
 CLASS_SHARED_D_READER_IMPL(Axis, QFont, labelsFont, labelsFont);
 CLASS_SHARED_D_READER_IMPL(Axis, QString, labelsPrefix, labelsPrefix);
 CLASS_SHARED_D_READER_IMPL(Axis, QString, labelsSuffix, labelsSuffix);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsOpacity, labelsOpacity);
 
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, majorGridPen, majorGridPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorGridOpacity, majorGridOpacity)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, minorGridPen, minorGridPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorGridOpacity, minorGridOpacity)
 
 /* ============================ setter methods and undo commands ================= */
 STD_SETTER_CMD_IMPL_F_S(Axis, SetAutoScale, bool, autoScale, retransform);
 void Axis::setAutoScale(bool autoScale) {
 	Q_D(Axis);
 	if (autoScale != d->autoScale) {
 		exec(new AxisSetAutoScaleCmd(d, autoScale, ki18n("%1: set axis auto scaling")));
 
 		if (autoScale) {
 			CartesianPlot *plot = qobject_cast<CartesianPlot*>(parentAspect());
 			if (!plot)
 				return;
 
 			if (d->orientation == Axis::AxisHorizontal) {
 				d->end = plot->xMax();
 				d->start = plot->xMin();
 			} else {
 				d->end = plot->yMax();
 				d->start = plot->yMin();
 			}
 			retransform();
 			emit endChanged(d->end);
 			emit startChanged(d->start);
 		}
 	}
 }
 
 STD_SWAP_METHOD_SETTER_CMD_IMPL(Axis, SetVisible, bool, swapVisible);
 void Axis::setVisible(bool on) {
 	Q_D(Axis);
 	exec(new AxisSetVisibleCmd(d, on, on ? ki18n("%1: set visible") : ki18n("%1: set invisible")));
 }
 
 bool Axis::isVisible() const {
 	Q_D(const Axis);
 	return d->isVisible();
 }
 
 void Axis::setPrinting(bool on) {
 	Q_D(Axis);
 	d->setPrinting(on);
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetOrientation, Axis::AxisOrientation, orientation, retransform);
 void Axis::setOrientation( AxisOrientation orientation) {
 	Q_D(Axis);
 	if (orientation != d->orientation)
 		exec(new AxisSetOrientationCmd(d, orientation, ki18n("%1: set axis orientation")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetPosition, Axis::AxisPosition, position, retransform);
 void Axis::setPosition(AxisPosition position) {
 	Q_D(Axis);
 	if (position != d->position)
 		exec(new AxisSetPositionCmd(d, position, ki18n("%1: set axis position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetScaling, Axis::AxisScale, scale, retransformTicks);
 void Axis::setScale(AxisScale scale) {
 	Q_D(Axis);
 	if (scale != d->scale)
 		exec(new AxisSetScalingCmd(d, scale, ki18n("%1: set axis scale")));
 }
 
 STD_SETTER_CMD_IMPL_F(Axis, SetOffset, double, offset, retransform);
 void Axis::setOffset(double offset, bool undo) {
 	Q_D(Axis);
 	if (offset != d->offset) {
 		if (undo) {
 			exec(new AxisSetOffsetCmd(d, offset, ki18n("%1: set axis offset")));
 		} else {
 			d->offset = offset;
 			//don't need to call retransform() afterward
 			//since the only usage of this call is in CartesianPlot, where retransform is called for all children anyway.
 		}
 		emit positionChanged(offset);
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetStart, double, start, retransform);
 void Axis::setStart(double start) {
 	Q_D(Axis);
 	if (start != d->start)
 		exec(new AxisSetStartCmd(d, start, ki18n("%1: set axis start")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetEnd, double, end, retransform);
 void Axis::setEnd(double end) {
 	Q_D(Axis);
 	if (end != d->end)
 		exec(new AxisSetEndCmd(d, end, ki18n("%1: set axis end")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetZeroOffset, qreal, zeroOffset, retransform);
 void Axis::setZeroOffset(qreal zeroOffset) {
 	Q_D(Axis);
 	if (zeroOffset != d->zeroOffset)
 		exec(new AxisSetZeroOffsetCmd(d, zeroOffset, ki18n("%1: set axis zero offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetScalingFactor, qreal, scalingFactor, retransform);
 void Axis::setScalingFactor(qreal scalingFactor) {
 	Q_D(Axis);
 	if (scalingFactor != d->scalingFactor)
 		exec(new AxisSetScalingFactorCmd(d, scalingFactor, ki18n("%1: set axis scaling factor")));
 }
 
 //Title
 STD_SETTER_CMD_IMPL_F_S(Axis, SetTitleOffsetX, qreal, titleOffsetX, retransform);
 void Axis::setTitleOffsetX(qreal offset) {
 	Q_D(Axis);
 	if (offset != d->titleOffsetX)
 		exec(new AxisSetTitleOffsetXCmd(d, offset, ki18n("%1: set title offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetTitleOffsetY, qreal, titleOffsetY, retransform);
 void Axis::setTitleOffsetY(qreal offset) {
 	Q_D(Axis);
 	if (offset != d->titleOffsetY)
 		exec(new AxisSetTitleOffsetYCmd(d, offset, ki18n("%1: set title offset")));
 }
 
 //Line
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLinePen, QPen, linePen, recalcShapeAndBoundingRect);
 void Axis::setLinePen(const QPen &pen) {
 	Q_D(Axis);
 	if (pen != d->linePen)
 		exec(new AxisSetLinePenCmd(d, pen, ki18n("%1: set line style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLineOpacity, qreal, lineOpacity, update);
 void Axis::setLineOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->lineOpacity)
 		exec(new AxisSetLineOpacityCmd(d, opacity, ki18n("%1: set line opacity")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowType, Axis::ArrowType, arrowType, retransformArrow);
 void Axis::setArrowType(ArrowType type) {
 	Q_D(Axis);
 	if (type != d->arrowType)
 		exec(new AxisSetArrowTypeCmd(d, type, ki18n("%1: set arrow type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowPosition, Axis::ArrowPosition, arrowPosition, retransformArrow);
 void Axis::setArrowPosition(ArrowPosition position) {
 	Q_D(Axis);
 	if (position != d->arrowPosition)
 		exec(new AxisSetArrowPositionCmd(d, position, ki18n("%1: set arrow position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowSize, qreal, arrowSize, retransformArrow);
 void Axis::setArrowSize(qreal arrowSize) {
 	Q_D(Axis);
 	if (arrowSize != d->arrowSize)
 		exec(new AxisSetArrowSizeCmd(d, arrowSize, ki18n("%1: set arrow size")));
 }
 
 //Major ticks
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksDirection, Axis::TicksDirection, majorTicksDirection, retransformTicks);
 void Axis::setMajorTicksDirection(TicksDirection majorTicksDirection) {
 	Q_D(Axis);
 	if (majorTicksDirection != d->majorTicksDirection)
 		exec(new AxisSetMajorTicksDirectionCmd(d, majorTicksDirection, ki18n("%1: set major ticks direction")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksType, Axis::TicksType, majorTicksType, retransformTicks);
 void Axis::setMajorTicksType(TicksType majorTicksType) {
 	Q_D(Axis);
 	if (majorTicksType!= d->majorTicksType)
 		exec(new AxisSetMajorTicksTypeCmd(d, majorTicksType, ki18n("%1: set major ticks type")));
 }
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksNumber, int, majorTicksNumber, retransformTicks);
 void Axis::setMajorTicksNumber(int majorTicksNumber) {
 	Q_D(Axis);
 	if (majorTicksNumber != d->majorTicksNumber)
 		exec(new AxisSetMajorTicksNumberCmd(d, majorTicksNumber, ki18n("%1: set the total number of the major ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksIncrement, qreal, majorTicksIncrement, retransformTicks);
 void Axis::setMajorTicksIncrement(qreal majorTicksIncrement) {
 	Q_D(Axis);
 	if (majorTicksIncrement != d->majorTicksIncrement)
 		exec(new AxisSetMajorTicksIncrementCmd(d, majorTicksIncrement, ki18n("%1: set the increment for the major ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksColumn, const AbstractColumn*, majorTicksColumn, retransformTicks)
 void Axis::setMajorTicksColumn(const AbstractColumn* column) {
 	Q_D(Axis);
 	if (column != d->majorTicksColumn) {
 		exec(new AxisSetMajorTicksColumnCmd(d, column, ki18n("%1: assign major ticks' values")));
 
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Axis::retransformTicks);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Axis::majorTicksColumnAboutToBeRemoved);
 			//TODO: add disconnect in the undo-function
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksPen, QPen, majorTicksPen, recalcShapeAndBoundingRect);
 void Axis::setMajorTicksPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->majorTicksPen)
 		exec(new AxisSetMajorTicksPenCmd(d, pen, ki18n("%1: set major ticks style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksLength, qreal, majorTicksLength, retransformTicks);
 void Axis::setMajorTicksLength(qreal majorTicksLength) {
 	Q_D(Axis);
 	if (majorTicksLength != d->majorTicksLength)
 		exec(new AxisSetMajorTicksLengthCmd(d, majorTicksLength, ki18n("%1: set major ticks length")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksOpacity, qreal, majorTicksOpacity, update);
 void Axis::setMajorTicksOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->majorTicksOpacity)
 		exec(new AxisSetMajorTicksOpacityCmd(d, opacity, ki18n("%1: set major ticks opacity")));
 }
 
 //Minor ticks
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksDirection, Axis::TicksDirection, minorTicksDirection, retransformTicks);
 void Axis::setMinorTicksDirection(TicksDirection minorTicksDirection) {
 	Q_D(Axis);
 	if (minorTicksDirection != d->minorTicksDirection)
 		exec(new AxisSetMinorTicksDirectionCmd(d, minorTicksDirection, ki18n("%1: set minor ticks direction")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksType, Axis::TicksType, minorTicksType, retransformTicks);
 void Axis::setMinorTicksType(TicksType minorTicksType) {
 	Q_D(Axis);
 	if (minorTicksType!= d->minorTicksType)
 		exec(new AxisSetMinorTicksTypeCmd(d, minorTicksType, ki18n("%1: set minor ticks type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksNumber, int, minorTicksNumber, retransformTicks);
 void Axis::setMinorTicksNumber(int minorTicksNumber) {
 	Q_D(Axis);
 	if (minorTicksNumber != d->minorTicksNumber)
 		exec(new AxisSetMinorTicksNumberCmd(d, minorTicksNumber, ki18n("%1: set the total number of the minor ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksIncrement, qreal, minorTicksIncrement, retransformTicks);
 void Axis::setMinorTicksIncrement(qreal minorTicksIncrement) {
 	Q_D(Axis);
 	if (minorTicksIncrement != d->minorTicksIncrement)
 		exec(new AxisSetMinorTicksIncrementCmd(d, minorTicksIncrement, ki18n("%1: set the increment for the minor ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksColumn, const AbstractColumn*, minorTicksColumn, retransformTicks)
 void Axis::setMinorTicksColumn(const AbstractColumn* column) {
 	Q_D(Axis);
 	if (column != d->minorTicksColumn) {
 		exec(new AxisSetMinorTicksColumnCmd(d, column, ki18n("%1: assign minor ticks' values")));
 
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Axis::retransformTicks);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Axis::minorTicksColumnAboutToBeRemoved);
 			//TODO: add disconnect in the undo-function
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksPen, QPen, minorTicksPen, recalcShapeAndBoundingRect);
 void Axis::setMinorTicksPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->minorTicksPen)
 		exec(new AxisSetMinorTicksPenCmd(d, pen, ki18n("%1: set minor ticks style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksLength, qreal, minorTicksLength, retransformTicks);
 void Axis::setMinorTicksLength(qreal minorTicksLength) {
 	Q_D(Axis);
 	if (minorTicksLength != d->minorTicksLength)
 		exec(new AxisSetMinorTicksLengthCmd(d, minorTicksLength, ki18n("%1: set minor ticks length")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksOpacity, qreal, minorTicksOpacity, update);
 void Axis::setMinorTicksOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->minorTicksOpacity)
 		exec(new AxisSetMinorTicksOpacityCmd(d, opacity, ki18n("%1: set minor ticks opacity")));
 }
 
 //Labels
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsFormat, Axis::LabelsFormat, labelsFormat, retransformTicks);
 void Axis::setLabelsFormat(LabelsFormat labelsFormat) {
 	Q_D(Axis);
 	if (labelsFormat != d->labelsFormat) {
 		exec(new AxisSetLabelsFormatCmd(d, labelsFormat, ki18n("%1: set labels format")));
 
 		//TODO: this part is not undo/redo-aware
 		if (d->labelsFormatAutoChanged && labelsFormat == Axis::FormatDecimal)
 			d->labelsFormatDecimalOverruled = true;
 		else
 			d->labelsFormatDecimalOverruled = false;
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsAutoPrecision, bool, labelsAutoPrecision, retransformTickLabelStrings);
 void Axis::setLabelsAutoPrecision(bool labelsAutoPrecision) {
 	Q_D(Axis);
 	if (labelsAutoPrecision != d->labelsAutoPrecision)
 		exec(new AxisSetLabelsAutoPrecisionCmd(d, labelsAutoPrecision, ki18n("%1: set labels precision")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPrecision, int, labelsPrecision, retransformTickLabelStrings);
 void Axis::setLabelsPrecision(int labelsPrecision) {
 	Q_D(Axis);
 	if (labelsPrecision != d->labelsPrecision)
 		exec(new AxisSetLabelsPrecisionCmd(d, labelsPrecision, ki18n("%1: set labels precision")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsDateTimeFormat, QString, labelsDateTimeFormat, retransformTickLabelStrings);
 void Axis::setLabelsDateTimeFormat(const QString& format) {
 	Q_D(Axis);
 	if (format != d->labelsDateTimeFormat)
 		exec(new AxisSetLabelsDateTimeFormatCmd(d, format, ki18n("%1: set labels datetime format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPosition, Axis::LabelsPosition, labelsPosition, retransformTickLabelPositions);
 void Axis::setLabelsPosition(LabelsPosition labelsPosition) {
 	Q_D(Axis);
 	if (labelsPosition != d->labelsPosition)
 		exec(new AxisSetLabelsPositionCmd(d, labelsPosition, ki18n("%1: set labels position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsOffset, double, labelsOffset, retransformTickLabelPositions);
 void Axis::setLabelsOffset(double offset) {
 	Q_D(Axis);
 	if (offset != d->labelsOffset)
 		exec(new AxisSetLabelsOffsetCmd(d, offset, ki18n("%1: set label offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsRotationAngle, qreal, labelsRotationAngle, recalcShapeAndBoundingRect);
 void Axis::setLabelsRotationAngle(qreal angle) {
 	Q_D(Axis);
 	if (angle != d->labelsRotationAngle)
 		exec(new AxisSetLabelsRotationAngleCmd(d, angle, ki18n("%1: set label rotation angle")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsColor, QColor, labelsColor, update);
 void Axis::setLabelsColor(const QColor& color) {
 	Q_D(Axis);
 	if (color != d->labelsColor)
 		exec(new AxisSetLabelsColorCmd(d, color, ki18n("%1: set label color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsFont, QFont, labelsFont, retransformTickLabelStrings);
 void Axis::setLabelsFont(const QFont& font) {
 	Q_D(Axis);
 	if (font != d->labelsFont)
 		exec(new AxisSetLabelsFontCmd(d, font, ki18n("%1: set label font")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPrefix, QString, labelsPrefix, retransformTickLabelStrings);
 void Axis::setLabelsPrefix(const QString& prefix) {
 	Q_D(Axis);
 	if (prefix != d->labelsPrefix)
 		exec(new AxisSetLabelsPrefixCmd(d, prefix, ki18n("%1: set label prefix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsSuffix, QString, labelsSuffix, retransformTickLabelStrings);
 void Axis::setLabelsSuffix(const QString& suffix) {
 	Q_D(Axis);
 	if (suffix != d->labelsSuffix)
 		exec(new AxisSetLabelsSuffixCmd(d, suffix, ki18n("%1: set label suffix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsOpacity, qreal, labelsOpacity, update);
 void Axis::setLabelsOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->labelsOpacity)
 		exec(new AxisSetLabelsOpacityCmd(d, opacity, ki18n("%1: set labels opacity")));
 }
 
 //Major grid
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorGridPen, QPen, majorGridPen, retransformMajorGrid);
 void Axis::setMajorGridPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->majorGridPen)
 		exec(new AxisSetMajorGridPenCmd(d, pen, ki18n("%1: set major grid style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorGridOpacity, qreal, majorGridOpacity, update);
 void Axis::setMajorGridOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->majorGridOpacity)
 		exec(new AxisSetMajorGridOpacityCmd(d, opacity, ki18n("%1: set major grid opacity")));
 }
 
 //Minor grid
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorGridPen, QPen, minorGridPen, retransformMinorGrid);
 void Axis::setMinorGridPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->minorGridPen)
 		exec(new AxisSetMinorGridPenCmd(d, pen, ki18n("%1: set minor grid style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorGridOpacity, qreal, minorGridOpacity, update);
 void Axis::setMinorGridOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->minorGridOpacity)
 		exec(new AxisSetMinorGridOpacityCmd(d, opacity, ki18n("%1: set minor grid opacity")));
 }
 
 //##############################################################################
 //####################################  SLOTs   ################################
 //##############################################################################
 void Axis::labelChanged() {
 	Q_D(Axis);
 	d->recalcShapeAndBoundingRect();
 }
 
 void Axis::retransformTicks() {
 	Q_D(Axis);
 	d->retransformTicks();
 }
 
 void Axis::majorTicksColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Axis);
 	if (aspect == d->majorTicksColumn) {
 		d->majorTicksColumn = nullptr;
 		d->retransformTicks();
 	}
 }
 
 void Axis::minorTicksColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Axis);
 	if (aspect == d->minorTicksColumn) {
 		d->minorTicksColumn = nullptr;
 		d->retransformTicks();
 	}
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void Axis::orientationChangedSlot(QAction* action) {
 	if (action == orientationHorizontalAction)
 		this->setOrientation(AxisHorizontal);
 	else
 		this->setOrientation(AxisVertical);
 }
 
 void Axis::lineStyleChanged(QAction* action) {
 	Q_D(const Axis);
 	QPen pen = d->linePen;
 	pen.setStyle(GuiTools::penStyleFromAction(lineStyleActionGroup, action));
 	this->setLinePen(pen);
 }
 
 void Axis::lineColorChanged(QAction* action) {
 	Q_D(const Axis);
 	QPen pen = d->linePen;
 	pen.setColor(GuiTools::colorFromAction(lineColorActionGroup, action));
 	this->setLinePen(pen);
 }
 
 void Axis::visibilityChangedSlot() {
 	Q_D(const Axis);
 	this->setVisible(!d->isVisible());
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 AxisPrivate::AxisPrivate(Axis* owner) :
 	majorTicksColumn(nullptr),
 	minorTicksColumn(nullptr),
 	gridItem(new AxisGrid(this)),
 	q(owner),
 	suppressRetransform(false),
 	labelsFormatDecimalOverruled(false),
 	labelsFormatAutoChanged(false),
 	plot(nullptr),
 	cSystem(nullptr),
 	m_hovered(false),
 	m_suppressRecalc(false),
 	m_printing(false) {
 
 	setFlag(QGraphicsItem::ItemIsSelectable, true);
 	setFlag(QGraphicsItem::ItemIsFocusable, true);
 	setAcceptHoverEvents(true);
 }
 
 QString AxisPrivate::name() const{
 	return q->name();
 }
 
 bool AxisPrivate::swapVisible(bool on) {
 	bool oldValue = isVisible();
 	setVisible(on);
 	emit q->visibilityChanged(on);
 	return oldValue;
 }
 
 QRectF AxisPrivate::boundingRect() const{
 	return boundingRectangle;
 }
 
 /*!
   Returns the shape of the XYCurve as a QPainterPath in local coordinates
 */
 QPainterPath AxisPrivate::shape() const{
 	return axisShape;
 }
 
 /*!
 	recalculates the position of the axis on the worksheet
  */
 void AxisPrivate::retransform() {
 	if (suppressRetransform || !plot)
 		return;
 
 // 	PERFTRACE(name().toLatin1() + ", AxisPrivate::retransform()");
 	m_suppressRecalc = true;
 	retransformLine();
 	m_suppressRecalc = false;
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformLine() {
 	if (suppressRetransform)
 		return;
 
 	linePath = QPainterPath();
 	lines.clear();
 
 	QPointF startPoint;
 	QPointF endPoint;
 
 	if (orientation == Axis::AxisHorizontal) {
 		if (position == Axis::AxisTop)
 			offset = plot->yMax();
 		else if (position == Axis::AxisBottom)
 			offset = plot->yMin();
 		else if (position == Axis::AxisCentered)
 			offset = plot->yMin() + (plot->yMax()-plot->yMin())/2;
 
 		startPoint.setX(start);
 		startPoint.setY(offset);
 		endPoint.setX(end);
 		endPoint.setY(offset);
 	} else { // vertical
 		if (position == Axis::AxisLeft)
 			offset = plot->xMin();
 		else if (position == Axis::AxisRight)
 			offset = plot->xMax();
 		else if (position == Axis::AxisCentered)
 			offset = plot->xMin() + (plot->xMax()-plot->xMin())/2;
 
 		startPoint.setX(offset);
 		startPoint.setY(start);
 		endPoint.setY(end);
 		endPoint.setX(offset);
 	}
 
 	lines.append(QLineF(startPoint, endPoint));
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::MarkGaps);
 	for (const auto& line : lines) {
 		linePath.moveTo(line.p1());
 		linePath.lineTo(line.p2());
 	}
 
 	if (linePath.isEmpty()) {
 		recalcShapeAndBoundingRect();
 		return;
 	} else {
 		retransformArrow();
 		retransformTicks();
 	}
 }
 
 void AxisPrivate::retransformArrow() {
 	if (suppressRetransform)
 		return;
 
 	arrowPath = QPainterPath();
 	if (arrowType == Axis::NoArrow || lines.isEmpty()) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	if (arrowPosition == Axis::ArrowRight || arrowPosition == Axis::ArrowBoth) {
 		const QPointF& endPoint = lines.at(lines.size()-1).p2();
 		this->addArrow(endPoint, 1);
 	}
 
 	if (arrowPosition == Axis::ArrowLeft || arrowPosition == Axis::ArrowBoth) {
 		const QPointF& endPoint = lines.at(0).p1();
 		this->addArrow(endPoint, -1);
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::addArrow(QPointF startPoint, int direction) {
 	static const double cos_phi = cos(M_PI/6.);
 
 	if (orientation == Axis::AxisHorizontal) {
 		QPointF endPoint = QPointF(startPoint.x() + direction*arrowSize, startPoint.y());
 		arrowPath.moveTo(startPoint);
 		arrowPath.lineTo(endPoint);
 
 		switch (arrowType) {
 			case Axis::NoArrow:
 				break;
 			case Axis::SimpleArrowSmall:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				break;
 			case Axis::SimpleArrowBig:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				break;
 			case Axis::FilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::FilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/8, endPoint.y()));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 		}
 	} else { //vertical orientation
 		QPointF endPoint = QPointF(startPoint.x(), startPoint.y()-direction*arrowSize);
 		arrowPath.moveTo(startPoint);
 		arrowPath.lineTo(endPoint);
 
 		switch (arrowType) {
 			case Axis::NoArrow:
 				break;
 			case Axis::SimpleArrowSmall:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				break;
 			case Axis::SimpleArrowBig:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				break;
 			case Axis::FilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::FilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x(), endPoint.y()+direction*arrowSize/8));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(QPointF(endPoint.x(), endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(endPoint);
 				break;
 		}
 	}
 }
 
 //! helper function for retransformTicks()
 bool AxisPrivate::transformAnchor(QPointF* anchorPoint) {
 	QVector<QPointF> points;
 	points.append(*anchorPoint);
 	points = cSystem->mapLogicalToScene(points);
 
 	if (points.count() != 1) { // point is not mappable or in a coordinate gap
 		return false;
 	} else {
 		*anchorPoint = points.at(0);
 		return true;
 	}
 }
 
 /*!
 	recalculates the position of the axis ticks.
  */
 void AxisPrivate::retransformTicks() {
 	if (suppressRetransform)
 		return;
 
 	//TODO: check that start and end are > 0 for log and >=0 for sqrt, etc.
 
 	majorTicksPath = QPainterPath();
 	minorTicksPath = QPainterPath();
 	majorTickPoints.clear();
 	minorTickPoints.clear();
 	tickLabelValues.clear();
 
 	if ( majorTicksNumber < 1 || (majorTicksDirection == Axis::noTicks && minorTicksDirection == Axis::noTicks) ) {
 		retransformTickLabelPositions(); //this calls recalcShapeAndBoundingRect()
 		return;
 	}
 
 	//determine the spacing for the major ticks
 	double majorTicksSpacing = 0;
 	int tmpMajorTicksNumber = 0;
 	if (majorTicksType == Axis::TicksTotalNumber) {
 		//the total number of the major ticks is given - > determine the spacing
 		tmpMajorTicksNumber = majorTicksNumber;
 		switch (scale) {
 			case Axis::ScaleLinear:
 				majorTicksSpacing = (end-start)/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLog10:
 				majorTicksSpacing = (log10(end)-log10(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLog2:
 				majorTicksSpacing = (log(end)-log(start))/log(2)/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLn:
 				majorTicksSpacing = (log(end)-log(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleSqrt:
 				majorTicksSpacing = (sqrt(end)-sqrt(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleX2:
 				majorTicksSpacing = (pow(end,2)-pow(start,2))/(majorTicksNumber-1);
 		}
 	} else if (majorTicksType == Axis::TicksIncrement) {
 		//the spacing (increment) of the major ticks is given - > determine the number
 		majorTicksSpacing = majorTicksIncrement;
 		switch (scale) {
 			case Axis::ScaleLinear:
 				tmpMajorTicksNumber = qRound((end-start)/majorTicksSpacing + 1);
 				break;
 			case Axis::ScaleLog10:
 				tmpMajorTicksNumber = qRound((log10(end)-log10(start))/majorTicksSpacing + 1);
 				break;
 			case Axis::ScaleLog2:
 				tmpMajorTicksNumber = qRound((log(end)-log(start))/log(2)/majorTicksSpacing + 1);
 				break;
 			case Axis::ScaleLn:
 				tmpMajorTicksNumber = qRound((log(end)-log(start))/majorTicksSpacing + 1);
 				break;
 			case Axis::ScaleSqrt:
 				tmpMajorTicksNumber = qRound((sqrt(end)-sqrt(start))/majorTicksSpacing + 1);
 				break;
 			case Axis::ScaleX2:
 				tmpMajorTicksNumber = qRound((pow(end,2)-pow(start,2))/majorTicksSpacing + 1);
 		}
 	} else {
 		//custom column was provided
 		if (majorTicksColumn) {
 			tmpMajorTicksNumber = majorTicksColumn->rowCount();
 		} else {
 			retransformTickLabelPositions(); //this calls recalcShapeAndBoundingRect()
 			return;
 		}
 	}
 
 	int tmpMinorTicksNumber;
 	if (minorTicksType == Axis::TicksTotalNumber)
 		tmpMinorTicksNumber = minorTicksNumber;
 	else if (minorTicksType == Axis::TicksIncrement)
 		tmpMinorTicksNumber = (end - start)/ (majorTicksNumber - 1)/minorTicksIncrement - 1;
 	else
 		(minorTicksColumn) ? tmpMinorTicksNumber = minorTicksColumn->rowCount() : tmpMinorTicksNumber = 0;
 
 	QPointF anchorPoint;
 	QPointF startPoint;
 	QPointF endPoint;
 	qreal majorTickPos=0.0;
 	qreal minorTickPos;
 	qreal nextMajorTickPos = 0.0;
 	const int xDirection = cSystem->xDirection();
 	const int yDirection = cSystem->yDirection();
 	const double middleX = plot->xMin() + (plot->xMax() - plot->xMin())/2;
 	const double middleY = plot->yMin() + (plot->yMax() - plot->yMin())/2;
 	bool valid;
 
 	for (int iMajor = 0; iMajor < tmpMajorTicksNumber; iMajor++) {
 		//calculate major tick's position
 		if (majorTicksType != Axis::TicksCustomColumn) {
 			switch (scale) {
 				case Axis::ScaleLinear:
 					majorTickPos = start + majorTicksSpacing*iMajor;
 					nextMajorTickPos = start + majorTicksSpacing*(iMajor+1);
 					break;
 				case Axis::ScaleLog10:
 					majorTickPos = pow(10, log10(start) + majorTicksSpacing*iMajor);
 					nextMajorTickPos = pow(10, log10(start) + majorTicksSpacing*(iMajor+1));
 					break;
 				case Axis::ScaleLog2:
 					majorTickPos = pow(2, log(start)/log(2) + majorTicksSpacing*iMajor);
 					nextMajorTickPos = pow(2, log(start)/log(2) + majorTicksSpacing*(iMajor+1));
 					break;
 				case Axis::ScaleLn:
 					majorTickPos = exp(log(start) + majorTicksSpacing*iMajor);
 					nextMajorTickPos = exp(log(start) + majorTicksSpacing*(iMajor+1));
 					break;
 				case Axis::ScaleSqrt:
 					majorTickPos = pow(sqrt(start) + majorTicksSpacing*iMajor, 2);
 					nextMajorTickPos = pow(sqrt(start) + majorTicksSpacing*(iMajor+1), 2);
 					break;
 				case Axis::ScaleX2:
 					majorTickPos = sqrt(sqrt(start) + majorTicksSpacing*iMajor);
 					nextMajorTickPos = sqrt(sqrt(start) + majorTicksSpacing*(iMajor+1));
 					break;
 			}
 		} else {
 			majorTickPos = majorTicksColumn->valueAt(iMajor);
 			if (std::isnan(majorTickPos))
 				break; //stop iterating after the first non numerical value in the column
 		}
 
 		//calculate start and end points for major tick's line
 		if (majorTicksDirection != Axis::noTicks ) {
 			if (orientation == Axis::AxisHorizontal) {
 				anchorPoint.setX(majorTickPos);
 				anchorPoint.setY(offset);
 				valid = transformAnchor(&anchorPoint);
 				if (valid) {
 					if (offset < middleY) {
 						startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn)  ? yDirection * majorTicksLength  : 0);
 						endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut) ? -yDirection * majorTicksLength : 0);
 					} else {
 						startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut)  ? yDirection * majorTicksLength  : 0);
 						endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn) ? -yDirection * majorTicksLength : 0);
 					}
 				}
 			} else { // vertical
 				anchorPoint.setY(majorTickPos);
 				anchorPoint.setX(offset);
 				valid = transformAnchor(&anchorPoint);
 
 				if (valid) {
 					if (offset < middleX) {
 						startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? xDirection * majorTicksLength  : 0, 0);
 						endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? -xDirection * majorTicksLength : 0, 0);
 					} else {
 						startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? xDirection * majorTicksLength : 0, 0);
 						endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? -xDirection *  majorTicksLength  : 0, 0);
 					}
 				}
 			}
 
 			//add major tick's line to the painter path
 			if (valid) {
 				majorTicksPath.moveTo(startPoint);
 				majorTicksPath.lineTo(endPoint);
 				majorTickPoints << anchorPoint;
 				tickLabelValues<< scalingFactor*majorTickPos+zeroOffset;
 			}
 		}
 
 		//minor ticks
 		if ((Axis::noTicks != minorTicksDirection) && (tmpMajorTicksNumber > 1) && (tmpMinorTicksNumber > 0) && (iMajor<tmpMajorTicksNumber-1)) {
 			//minor ticks are placed at equidistant positions independent of the selected scaling for the major ticks positions
 			double minorTicksSpacing = (nextMajorTickPos-majorTickPos)/(tmpMinorTicksNumber+1);
 
 			for (int iMinor = 0; iMinor < tmpMinorTicksNumber; iMinor++) {
 				//calculate minor tick's position
 				if (minorTicksType != Axis::TicksCustomColumn) {
 					minorTickPos = majorTickPos + (iMinor+1)*minorTicksSpacing;
 				} else {
 					minorTickPos = minorTicksColumn->valueAt(iMinor);
 					if (std::isnan(minorTickPos))
 						break; //stop iterating after the first non numerical value in the column
 
 					//in the case a custom column is used for the minor ticks, we draw them _once_ for the whole range of the axis.
 					//execute the minor ticks loop only once.
 					if (iMajor > 0)
 						break;
 				}
 
 				//calculate start and end points for minor tick's line
 				if (orientation == Axis::AxisHorizontal) {
 					anchorPoint.setX(minorTickPos);
 					anchorPoint.setY(offset);
 					valid = transformAnchor(&anchorPoint);
 
 					if (valid) {
 						if (offset < middleY) {
 							startPoint = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksIn)  ? yDirection * minorTicksLength  : 0);
 							endPoint   = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksOut) ? -yDirection * minorTicksLength : 0);
 						} else {
 							startPoint = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksOut)  ? yDirection * minorTicksLength  : 0);
 							endPoint   = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksIn) ? -yDirection * minorTicksLength : 0);
 						}
 					}
 				} else { // vertical
 					anchorPoint.setY(minorTickPos);
 					anchorPoint.setX(offset);
 					valid = transformAnchor(&anchorPoint);
 
 					if (valid) {
 						if (offset < middleX) {
 							startPoint = anchorPoint + QPointF((minorTicksDirection & Axis::ticksIn)  ? xDirection * minorTicksLength  : 0, 0);
 							endPoint   = anchorPoint + QPointF((minorTicksDirection & Axis::ticksOut) ? -xDirection * minorTicksLength : 0, 0);
 						} else {
 							startPoint = anchorPoint + QPointF((minorTicksDirection & Axis::ticksOut)  ? xDirection * minorTicksLength  : 0, 0);
 							endPoint   = anchorPoint + QPointF((minorTicksDirection & Axis::ticksIn) ? -xDirection * minorTicksLength : 0, 0);
 						}
 					}
 				}
 
 				//add minor tick's line to the painter path
 				if (valid) {
 					minorTicksPath.moveTo(startPoint);
 					minorTicksPath.lineTo(endPoint);
 					minorTickPoints << anchorPoint;
 				}
 			}
 		}
 	}
 
 	//tick positions where changed -> update the position of the tick labels and grid lines
 	retransformTickLabelStrings();
 	retransformMajorGrid();
 	retransformMinorGrid();
 }
 
 /*!
 	creates the tick label strings starting with the most optimal
 	(=the smallest possible number of float digits) precision for the floats
 */
 void AxisPrivate::retransformTickLabelStrings() {
 	if (suppressRetransform)
 		return;
 
 // 	DEBUG("AxisPrivate::retransformTickLabelStrings()");
 	if (labelsAutoPrecision) {
 		//check, whether we need to increase the current precision
 		int newPrecision = upperLabelsPrecision(labelsPrecision);
 		if (newPrecision!= labelsPrecision) {
 			labelsPrecision = newPrecision;
 			emit q->labelsPrecisionChanged(labelsPrecision);
 		} else {
 			//check, whether we can reduce the current precision
 			newPrecision = lowerLabelsPrecision(labelsPrecision);
 			if (newPrecision!= labelsPrecision) {
 				labelsPrecision = newPrecision;
 				emit q->labelsPrecisionChanged(labelsPrecision);
 			}
 		}
 	}
 // 	DEBUG("labelsPrecision =" << labelsPrecision);
 
 	//automatically switch from 'decimal' to 'scientific' format for big numbers (>10^4)
 	//and back to decimal when the numbers get smaller after the auto-switch again
 	if (labelsFormat == Axis::FormatDecimal && !labelsFormatDecimalOverruled) {
 		for (auto value : tickLabelValues) {
 			if (std::abs(value) > 1e4) {
 				labelsFormat = Axis::FormatScientificE;
 				emit q->labelsFormatChanged(labelsFormat);
 				labelsFormatAutoChanged = true;
 				break;
 			}
 		}
 	} else if (labelsFormatAutoChanged ) {
 		//check whether we still have big numbers
 		bool changeBack = true;
 		for (auto value : tickLabelValues) {
 			if (std::abs(value) > 1e4) {
 				changeBack = false;
 				break;
 			}
 		}
 
 		if (changeBack) {
 			labelsFormatAutoChanged = false;
 			labelsFormat = Axis::FormatDecimal;
 			emit q->labelsFormatChanged(labelsFormat);
 		}
 	}
 
 	tickLabelStrings.clear();
 	QString str;
 	if ( (orientation == Axis::AxisHorizontal && plot->xRangeFormat() == CartesianPlot::Numeric)
 		|| (orientation == Axis::AxisVertical && plot->yRangeFormat() == CartesianPlot::Numeric) ) {
 		if (labelsFormat == Axis::FormatDecimal) {
 			QString nullStr = QString::number(0, 'f', labelsPrecision);
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = QString::number(value, 'f', labelsPrecision);
 				if (str == "-" + nullStr) str = nullStr;
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatScientificE) {
 			QString nullStr = QString::number(0, 'e', labelsPrecision);
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = QString::number(value, 'e', labelsPrecision);
 				if (str == "-" + nullStr) str = nullStr;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowers10) {
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = "10<span style=\"vertical-align:super\">" + QString::number(log10(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowers2) {
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = "2<span style=\"vertical-align:super\">" + QString::number(log2(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowersE) {
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = "e<span style=\"vertical-align:super\">" + QString::number(log(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatMultipliesPi) {
-			for (auto value : tickLabelValues) {
+			for (const auto value : tickLabelValues) {
 				str = "<span>" + QString::number(value / M_PI, 'f', labelsPrecision) + "</span>" + QChar(0x03C0);
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		}
 	} else {
-		for (auto value : tickLabelValues) {
+		for (const auto value : tickLabelValues) {
 			QDateTime dateTime;
 			dateTime.setMSecsSinceEpoch(value);
 			str = dateTime.toString(labelsDateTimeFormat);
 			str = labelsPrefix + str + labelsSuffix;
 			tickLabelStrings << str;
 		}
 	}
 
 	//recalculate the position of the tick labels
 	retransformTickLabelPositions();
 }
 
 /*!
 	returns the smallest upper limit for the precision
 	where no duplicates for the tick label float occur.
  */
 int AxisPrivate::upperLabelsPrecision(int precision) {
 // 	DEBUG("AxisPrivate::upperLabelsPrecision() precision =" << precision);
 	//round float to the current precision and look for duplicates.
 	//if there are duplicates, increase the precision.
 	QVector<double> tempValues;
-	for (auto value: tickLabelValues)
+	for (const auto value : tickLabelValues)
 		tempValues.append( nsl_math_round_places(value, precision) );
 
 	for (int i = 0; i < tempValues.size(); ++i) {
 		for (int j = 0; j < tempValues.size(); ++j) {
 			if (i == j) continue;
 				if (tempValues.at(i) == tempValues.at(j)) {
 				//duplicate for the current precision found, increase the precision and check again
 				return upperLabelsPrecision(precision + 1);
 			}
 		}
 	}
 
 	//no duplicates for the current precision found: return the current value
 	DEBUG("	upper precision = " << precision);
 	return precision;
 }
 
 /*!
 	returns highest lower limit for the precision
 	where no duplicates for the tick label float occur.
 */
 int AxisPrivate::lowerLabelsPrecision(int precision) {
 // 	DEBUG("AxisPrivate::lowerLabelsPrecision() precision =" << precision);
 	//round float to the current precision and look for duplicates.
 	//if there are duplicates, decrease the precision.
 	QVector<double> tempValues;
-	for (auto value: tickLabelValues)
+	for (const auto value : tickLabelValues)
 		tempValues.append( nsl_math_round_places(value, precision-1) );
 
 	for (int i = 0; i < tempValues.size(); ++i) {
 		for (int j = 0; j < tempValues.size(); ++j) {
 			if (i == j) continue;
 			if (tempValues.at(i) == tempValues.at(j)) {
 				//duplicate found for the reduced precision
 				//-> current precision cannot be reduced, return the current value
 				DEBUG("	lower precision = " << precision);
 				return precision;
 			}
 		}
 	}
 
 	//no duplicates found, reduce further, and check again
 	if (precision == 0)
 		return 0;
 	else
 		return lowerLabelsPrecision(precision - 1);
 }
 
 /*!
 	recalculates the position of the tick labels.
 	Called when the geometry related properties (position, offset, font size, suffix, prefix) of the labels are changed.
  */
 void AxisPrivate::retransformTickLabelPositions() {
 	tickLabelPoints.clear();
 	if (majorTicksDirection == Axis::noTicks || labelsPosition == Axis::NoLabels) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	QFontMetrics fm(labelsFont);
 	float width = 0;
 	float height = fm.ascent();
 	QPointF pos;
 	const double middleX = plot->xMin() + (plot->xMax() - plot->xMin())/2;
 	const double middleY = plot->yMin() + (plot->yMax() - plot->yMin())/2;
 	const int xDirection = cSystem->xDirection();
 	const int yDirection = cSystem->yDirection();
 
 	QPointF startPoint, endPoint, anchorPoint;
 
 	QTextDocument td;
 	td.setDefaultFont(labelsFont);
 
 	for ( int i = 0; i < majorTickPoints.size(); i++ ) {
 		if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 			width = fm.width(tickLabelStrings.at(i));
 		} else {
 			td.setHtml(tickLabelStrings.at(i));
 			width = td.size().width();
 			height = td.size().height();
 		}
 		anchorPoint = majorTickPoints.at(i);
 
 		//center align all labels with respect to the end point of the tick line
 		if (orientation == Axis::AxisHorizontal) {
 			if (offset < middleY) {
 				startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn)  ? yDirection * majorTicksLength  : 0);
 				endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut) ? -yDirection * majorTicksLength : 0);
 			}
 			else {
 				startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut)  ? yDirection * majorTicksLength  : 0);
 				endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn) ? -yDirection * majorTicksLength : 0);
 			}
 			if (labelsPosition == Axis::LabelsOut) {
 				pos.setX( endPoint.x() - width/2);
 				pos.setY( endPoint.y() + height + labelsOffset );
 			} else {
 				pos.setX( startPoint.x() - width/2);
 				pos.setY( startPoint.y() - labelsOffset );
 			}
 		} else {// vertical
 			if (offset < middleX) {
 				startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? xDirection * majorTicksLength  : 0, 0);
 				endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? -xDirection * majorTicksLength : 0, 0);
 			} else {
 				startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? xDirection * majorTicksLength : 0, 0);
 				endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? -xDirection *  majorTicksLength  : 0, 0);
 			}
 			if (labelsPosition == Axis::LabelsOut) {
 				pos.setX( endPoint.x() - width - labelsOffset );
 				pos.setY( endPoint.y() + height/2 );
 			} else {
 				pos.setX( startPoint.x() + labelsOffset );
 				pos.setY( startPoint.y() + height/2 );
 			}
 		}
 		tickLabelPoints << pos;
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformMajorGrid() {
 	if (suppressRetransform)
 		return;
 
 	majorGridPath = QPainterPath();
 	if (majorGridPen.style() == Qt::NoPen || majorTickPoints.size() == 0) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//major tick points are already in scene coordinates, convert them back to logical...
 	//TODO: mapping should work without SuppressPageClipping-flag, check float comparisons in the map-function.
 	//Currently, grid lines disappear somtimes without this flag
 	QVector<QPointF> logicalMajorTickPoints = cSystem->mapSceneToLogical(majorTickPoints, AbstractCoordinateSystem::SuppressPageClipping);
 
 	if (logicalMajorTickPoints.isEmpty())
 		return;
 
 	//TODO:
 	//when iterating over all grid lines, skip the first and the last points for auto scaled axes,
 	//since we don't want to paint any grid lines at the plot boundaries
 	bool skipLowestTick, skipUpperTick;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		skipLowestTick = qFuzzyCompare(logicalMajorTickPoints.at(0).x(), plot->xMin());
 		skipUpperTick = qFuzzyCompare(logicalMajorTickPoints.at(logicalMajorTickPoints.size()-1).x(), plot->xMax());
 	} else {
 		skipLowestTick = qFuzzyCompare(logicalMajorTickPoints.at(0).y(), plot->yMin());
 		skipUpperTick = qFuzzyCompare(logicalMajorTickPoints.at(logicalMajorTickPoints.size()-1).y(), plot->yMax());
 	}
 
 	int start, end;
 	if (skipLowestTick) {
 		if (logicalMajorTickPoints.size() > 1)
 			start = 1;
 		else
 			start = 0;
 	} else {
 		start = 0;
 	}
 
 	if (skipUpperTick) {
 		if (logicalMajorTickPoints.size() > 1)
 			end = logicalMajorTickPoints.size() - 1;
 		else
 			end = 0;
 
 	} else {
 		end = logicalMajorTickPoints.size();
 	}
 
 	QVector<QLineF> lines;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		double yMin = plot->yMin();
 		double yMax = plot->yMax();
 
 		for (int i=start; i<end; ++i) {
 			const QPointF& point = logicalMajorTickPoints.at(i);
 			lines.append( QLineF(point.x(), yMin, point.x(), yMax) );
 		}
 	} else { //vertical axis
 		double xMin = plot->xMin();
 		double xMax = plot->xMax();
 
 		//skip the first and the last points, since we don't want to paint any grid lines at the plot boundaries
 		for (int i = start; i < end; ++i) {
 			const QPointF& point = logicalMajorTickPoints.at(i);
 			lines.append( QLineF(xMin, point.y(), xMax, point.y()) );
 		}
 	}
 
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::SuppressPageClipping);
 	for (const auto& line : lines) {
 		majorGridPath.moveTo(line.p1());
 		majorGridPath.lineTo(line.p2());
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformMinorGrid() {
 	if (suppressRetransform)
 		return;
 
 	minorGridPath = QPainterPath();
 	if (minorGridPen.style() == Qt::NoPen) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//minor tick points are already in scene coordinates, convert them back to logical...
 	//TODO: mapping should work without SuppressPageClipping-flag, check float comparisons in the map-function.
 	//Currently, grid lines disappear somtimes without this flag
 	QVector<QPointF> logicalMinorTickPoints = cSystem->mapSceneToLogical(minorTickPoints, AbstractCoordinateSystem::SuppressPageClipping);
 
 	QVector<QLineF> lines;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		double yMin = plot->yMin();
 		double yMax = plot->yMax();
 
-		for (auto point: logicalMinorTickPoints)
+		for (const auto point : logicalMinorTickPoints)
 			lines.append( QLineF(point.x(), yMin, point.x(), yMax) );
 	} else { //vertical axis
 		double xMin = plot->xMin();
 		double xMax = plot->xMax();
 
-		for (auto point: logicalMinorTickPoints)
+		for (const auto point: logicalMinorTickPoints)
 			lines.append( QLineF(xMin, point.y(), xMax, point.y()) );
 	}
 
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::SuppressPageClipping);
 	for (const auto& line : lines) {
 		minorGridPath.moveTo(line.p1());
 		minorGridPath.lineTo(line.p2());
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::recalcShapeAndBoundingRect() {
 	if (m_suppressRecalc)
 		return;
 
 	prepareGeometryChange();
 
 	if (linePath.isEmpty()) {
 		axisShape = QPainterPath();
 		boundingRectangle = QRectF();
 		title->setPositionInvalid(true);
 		if (plot) plot->prepareGeometryChange();
 		return;
 	} else {
 		title->setPositionInvalid(false);
 	}
 
 	axisShape = WorksheetElement::shapeFromPath(linePath, linePen);
 	axisShape.addPath(WorksheetElement::shapeFromPath(arrowPath, linePen));
 	axisShape.addPath(WorksheetElement::shapeFromPath(majorTicksPath, majorTicksPen));
 	axisShape.addPath(WorksheetElement::shapeFromPath(minorTicksPath, minorTicksPen));
 
 	QPainterPath  tickLabelsPath = QPainterPath();
 	if (labelsPosition != Axis::NoLabels) {
 		QTransform trafo;
 		QPainterPath tempPath;
 		QFontMetrics fm(labelsFont);
 		QTextDocument td;
 		td.setDefaultFont(labelsFont);
 		for (int i = 0; i < tickLabelPoints.size(); i++) {
 			tempPath = QPainterPath();
 			if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 				tempPath.addRect( fm.boundingRect(tickLabelStrings.at(i)) );
 			} else {
 				td.setHtml(tickLabelStrings.at(i));
 				tempPath.addRect( QRectF(0, -td.size().height(), td.size().width(), td.size().height()) );
 			}
 
 			trafo.reset();
 			trafo.translate( tickLabelPoints.at(i).x(), tickLabelPoints.at(i).y() );
 			trafo.rotate( -labelsRotationAngle );
 			tempPath = trafo.map(tempPath);
 
 			tickLabelsPath.addPath(WorksheetElement::shapeFromPath(tempPath, linePen));
 		}
 		axisShape.addPath(WorksheetElement::shapeFromPath(tickLabelsPath, QPen()));
 	}
 
 	//add title label, if available
 	if ( title->isVisible() && !title->text().text.isEmpty() ) {
 		//determine the new position of the title label:
 		//we calculate the new position here and not in retransform(),
 		//since it depends on the size and position of the tick labels, tickLabelsPath, available here.
 		QRectF rect=linePath.boundingRect();
 		qreal offsetX = titleOffsetX - labelsOffset; //the distance to the axis line
 		qreal offsetY = titleOffsetY - labelsOffset; //the distance to the axis line
 		if (orientation == Axis::AxisHorizontal) {
 			offsetY -= title->graphicsItem()->boundingRect().height()/2 + tickLabelsPath.boundingRect().height();
 			title->setPosition( QPointF( (rect.topLeft().x() + rect.topRight().x())/2 + offsetX, rect.bottomLeft().y() - offsetY ) );
 		} else {
 			offsetX -= title->graphicsItem()->boundingRect().width()/2 + tickLabelsPath.boundingRect().width();
 			title->setPosition( QPointF( rect.topLeft().x() + offsetX, (rect.topLeft().y() + rect.bottomLeft().y())/2 - offsetY) );
 		}
 		axisShape.addPath(WorksheetElement::shapeFromPath(title->graphicsItem()->mapToParent(title->graphicsItem()->shape()), linePen));
 	}
 
 	boundingRectangle = axisShape.boundingRect();
 
 	//if the axis goes beyond the current bounding box of the plot (too high offset is used, too long labels etc.)
 	//request a prepareGeometryChange() for the plot in order to properly keep track of geometry changes
 	if (plot)
 		plot->prepareGeometryChange();
 }
 
 /*!
 	paints the content of the axis. Reimplemented from \c QGraphicsItem.
 	\sa QGraphicsItem::paint()
  */
 void AxisPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	if (!isVisible())
 		return;
 
 	if (linePath.isEmpty())
 		return;
 
 	//draw the line
 	if (linePen.style() != Qt::NoPen) {
 		painter->setOpacity(lineOpacity);
 		painter->setPen(linePen);
 		painter->setBrush(Qt::SolidPattern);
 		painter->drawPath(linePath);
 
 		//draw the arrow
 		if (arrowType != Axis::NoArrow)
 			painter->drawPath(arrowPath);
 	}
 
 	//draw the major ticks
 	if (majorTicksDirection != Axis::noTicks) {
 		painter->setOpacity(majorTicksOpacity);
 		painter->setPen(majorTicksPen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(majorTicksPath);
 	}
 
 	//draw the minor ticks
 	if (minorTicksDirection != Axis::noTicks) {
 		painter->setOpacity(minorTicksOpacity);
 		painter->setPen(minorTicksPen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(minorTicksPath);
 	}
 
 	// draw tick labels
 	if (labelsPosition != Axis::NoLabels) {
 		painter->setOpacity(labelsOpacity);
 		painter->setPen(QPen(labelsColor));
 		painter->setFont(labelsFont);
 		QTextDocument td;
 		td.setDefaultFont(labelsFont);
 		for (int i = 0; i < tickLabelPoints.size(); i++) {
 			painter->translate(tickLabelPoints.at(i));
 			painter->save();
 			painter->rotate(-labelsRotationAngle);
 
 			if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 				painter->drawText(QPoint(0,0), tickLabelStrings.at(i));
 			} else {
 				td.setHtml(tickLabelStrings.at(i));
 				painter->translate(0, -td.size().height());
 				td.drawContents(painter);
 			}
 
 			painter->restore();
 			painter->translate(-tickLabelPoints.at(i));
 		}
 	}
 
 	if (m_hovered && !isSelected() && !m_printing){
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Shadow), 2, Qt::SolidLine));
 		painter->drawPath(axisShape);
 	}
 
 	if (isSelected() && !m_printing){
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Highlight), 2, Qt::SolidLine));
 		painter->drawPath(axisShape);
 	}
 }
 
 void AxisPrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	q->createContextMenu()->exec(event->screenPos());
 }
 
 void AxisPrivate::hoverEnterEvent(QGraphicsSceneHoverEvent*) {
 	if (!isSelected()) {
 		m_hovered = true;
 		emit q->hovered();
 		update(axisShape.boundingRect());
 	}
 }
 
 void AxisPrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent*) {
 	if (m_hovered) {
 		m_hovered = false;
 		emit q->unhovered();
 		update(axisShape.boundingRect());
 	}
 }
 
 void AxisPrivate::setPrinting(bool on) {
 	m_printing = on;
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void Axis::save(QXmlStreamWriter* writer) const{
 	Q_D(const Axis);
 
 	writer->writeStartElement( "axis" );
 	writeBasicAttributes( writer );
 	writeCommentElement( writer );
 
 	//general
 	writer->writeStartElement( "general" );
 	writer->writeAttribute( "autoScale", QString::number(d->autoScale) );
 	writer->writeAttribute( "orientation", QString::number(d->orientation) );
 	writer->writeAttribute( "position", QString::number(d->position) );
 	writer->writeAttribute( "scale", QString::number(d->scale) );
 	writer->writeAttribute( "offset", QString::number(d->offset) );
 	writer->writeAttribute( "start", QString::number(d->start) );
 	writer->writeAttribute( "end", QString::number(d->end) );
 	writer->writeAttribute( "scalingFactor", QString::number(d->scalingFactor) );
 	writer->writeAttribute( "zeroOffset", QString::number(d->zeroOffset) );
 	writer->writeAttribute( "titleOffsetX", QString::number(d->titleOffsetX) );
 	writer->writeAttribute( "titleOffsetY", QString::number(d->titleOffsetY) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//label
 	d->title->save( writer );
 
 	//line
 	writer->writeStartElement( "line" );
 	WRITE_QPEN(d->linePen);
 	writer->writeAttribute( "opacity", QString::number(d->lineOpacity) );
 	writer->writeAttribute( "arrowType", QString::number(d->arrowType) );
 	writer->writeAttribute( "arrowPosition", QString::number(d->arrowPosition) );
 	writer->writeAttribute( "arrowSize", QString::number(d->arrowSize) );
 	writer->writeEndElement();
 
 	//major ticks
 	writer->writeStartElement( "majorTicks" );
 	writer->writeAttribute( "direction", QString::number(d->majorTicksDirection) );
 	writer->writeAttribute( "type", QString::number(d->majorTicksType) );
 	writer->writeAttribute( "number", QString::number(d->majorTicksNumber) );
 	writer->writeAttribute( "increment", QString::number(d->majorTicksIncrement) );
 	WRITE_COLUMN(d->majorTicksColumn, majorTicksColumn);
 	writer->writeAttribute( "length", QString::number(d->majorTicksLength) );
 	WRITE_QPEN(d->majorTicksPen);
 	writer->writeAttribute( "opacity", QString::number(d->majorTicksOpacity) );
 	writer->writeEndElement();
 
 	//minor ticks
 	writer->writeStartElement( "minorTicks" );
 	writer->writeAttribute( "direction", QString::number(d->minorTicksDirection) );
 	writer->writeAttribute( "type", QString::number(d->minorTicksType) );
 	writer->writeAttribute( "number", QString::number(d->minorTicksNumber) );
 	writer->writeAttribute( "increment", QString::number(d->minorTicksIncrement) );
 	WRITE_COLUMN(d->minorTicksColumn, minorTicksColumn);
 	writer->writeAttribute( "length", QString::number(d->minorTicksLength) );
 	WRITE_QPEN(d->minorTicksPen);
 	writer->writeAttribute( "opacity", QString::number(d->minorTicksOpacity) );
 	writer->writeEndElement();
 
 	//extra ticks
 
 	//labels
 	writer->writeStartElement( "labels" );
 	writer->writeAttribute( "position", QString::number(d->labelsPosition) );
 	writer->writeAttribute( "offset", QString::number(d->labelsOffset) );
 	writer->writeAttribute( "rotation", QString::number(d->labelsRotationAngle) );
 	writer->writeAttribute( "format", QString::number(d->labelsFormat) );
 	writer->writeAttribute( "precision", QString::number(d->labelsPrecision) );
 	writer->writeAttribute( "autoPrecision", QString::number(d->labelsAutoPrecision) );
 	writer->writeAttribute( "dateTimeFormat", d->labelsDateTimeFormat );
 	WRITE_QCOLOR(d->labelsColor);
 	WRITE_QFONT(d->labelsFont);
 	writer->writeAttribute( "prefix", d->labelsPrefix );
 	writer->writeAttribute( "suffix", d->labelsSuffix );
 	writer->writeAttribute( "opacity", QString::number(d->labelsOpacity) );
 	writer->writeEndElement();
 
 	//grid
 	writer->writeStartElement( "majorGrid" );
 	WRITE_QPEN(d->majorGridPen);
 	writer->writeAttribute( "opacity", QString::number(d->majorGridOpacity) );
 	writer->writeEndElement();
 
 	writer->writeStartElement( "minorGrid" );
 	WRITE_QPEN(d->minorGridPen);
 	writer->writeAttribute( "opacity", QString::number(d->minorGridOpacity) );
 	writer->writeEndElement();
 
 	writer->writeEndElement(); // close "axis" section
 }
 
 //! Load from XML
 bool Axis::load(XmlStreamReader* reader, bool preview) {
 	Q_D(Axis);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "axis")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (!preview && reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (!preview && reader->name() == "general") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("autoScale", autoScale, bool);
 			READ_INT_VALUE("orientation", orientation, Axis::AxisOrientation);
 			READ_INT_VALUE("position", position, Axis::AxisPosition);
 			READ_INT_VALUE("scale", scale, Axis::AxisScale);
 			READ_DOUBLE_VALUE("offset", offset);
 			READ_DOUBLE_VALUE("start", start);
 			READ_DOUBLE_VALUE("end", end);
 			READ_DOUBLE_VALUE("scalingFactor", scalingFactor);
 			READ_DOUBLE_VALUE("zeroOffset", zeroOffset);
 			READ_DOUBLE_VALUE("titleOffsetX", titleOffsetX);
 			READ_DOUBLE_VALUE("titleOffsetY", titleOffsetY);
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (reader->name() == "textLabel") {
 			d->title->load(reader, preview);
 		} else if (!preview && reader->name() == "line") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->linePen);
 			READ_DOUBLE_VALUE("opacity", lineOpacity);
 			READ_INT_VALUE("arrowType", arrowType, Axis::ArrowType);
 			READ_INT_VALUE("arrowPosition", arrowPosition, Axis::ArrowPosition);
 			READ_DOUBLE_VALUE("arrowSize", arrowSize);
 		} else if (!preview && reader->name() == "majorTicks") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("direction", majorTicksDirection, Axis::TicksDirection);
 			READ_INT_VALUE("type", majorTicksType, Axis::TicksType);
 			READ_INT_VALUE("number", majorTicksNumber, int);
 			READ_DOUBLE_VALUE("increment", majorTicksIncrement);
 			READ_COLUMN(majorTicksColumn);
 			READ_DOUBLE_VALUE("length", majorTicksLength);
 			READ_QPEN(d->majorTicksPen);
 			READ_DOUBLE_VALUE("opacity", majorTicksOpacity);
 		} else if (!preview && reader->name() == "minorTicks") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("direction", minorTicksDirection, Axis::TicksDirection);
 			READ_INT_VALUE("type", minorTicksType, Axis::TicksType);
 			READ_INT_VALUE("number", minorTicksNumber, int);
 			READ_DOUBLE_VALUE("increment", minorTicksIncrement);
 			READ_COLUMN(minorTicksColumn);
 			READ_DOUBLE_VALUE("length", minorTicksLength);
 			READ_QPEN(d->minorTicksPen);
 			READ_DOUBLE_VALUE("opacity", minorTicksOpacity);
 		} else if (!preview && reader->name() == "labels") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("position", labelsPosition, Axis::LabelsPosition);
 			READ_DOUBLE_VALUE("offset", labelsOffset);
 			READ_DOUBLE_VALUE("rotation", labelsRotationAngle);
 			READ_INT_VALUE("format", labelsFormat, Axis::LabelsFormat);
 			READ_INT_VALUE("precision", labelsPrecision, int);
 			READ_INT_VALUE("autoPrecision", labelsAutoPrecision, bool);
 			d->labelsDateTimeFormat = attribs.value("dateTimeFormat").toString();
 			READ_QCOLOR(d->labelsColor);
 			READ_QFONT(d->labelsFont);
 
 			//don't produce any warning if no prefix or suffix is set (empty string is allowed here in xml)
 			d->labelsPrefix = attribs.value("prefix").toString();
 			d->labelsSuffix = attribs.value("suffix").toString();
 
 			READ_DOUBLE_VALUE("opacity", labelsOpacity);
 		} else if (!preview && reader->name() == "majorGrid") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->majorGridPen);
 			READ_DOUBLE_VALUE("opacity", majorGridOpacity);
 		} else if (!preview && reader->name() == "minorGrid") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->minorGridPen);
 			READ_DOUBLE_VALUE("opacity", minorGridOpacity);
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void Axis::loadThemeConfig(const KConfig& config) {
 	const KConfigGroup group = config.group("Axis");
 
 	QPen p;
 	// Tick label
 	this->setLabelsColor(group.readEntry("LabelsFontColor",(QColor) this->labelsColor()));
 	this->setLabelsOpacity(group.readEntry("LabelsOpacity",this->labelsOpacity()));
 
 	//Line
 	this->setLineOpacity(group.readEntry("LineOpacity",this->lineOpacity()));
 	p.setColor(group.readEntry("LineColor", (QColor) this->linePen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("LineStyle",(int) this->linePen().style()));
 	p.setWidthF(group.readEntry("LineWidth", this->linePen().widthF()));
 	this->setLinePen(p);
 
 	//Major ticks
 	this->setMajorGridOpacity(group.readEntry("MajorGridOpacity", this->majorGridOpacity()));
 	p.setColor(group.readEntry("MajorGridColor",(QColor) this->majorGridPen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("MajorGridStyle",(int) this->majorGridPen().style()));
 	p.setWidthF(group.readEntry("MajorGridWidth", this->majorGridPen().widthF()));
 	this->setMajorGridPen(p);
 	p.setColor(group.readEntry("MajorTicksColor",(QColor)this->majorTicksPen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("MajorTicksLineStyle",(int) this->majorTicksPen().style()));
 	p.setWidthF(group.readEntry("MajorTicksWidth", this->majorTicksPen().widthF()));
 	this->setMajorTicksPen(p);
 	this->setMajorTicksOpacity(group.readEntry("MajorTicksOpacity",this->majorTicksOpacity()));
 
 	//Minor ticks
 	this->setMinorGridOpacity(group.readEntry("MinorGridOpacity", this->minorGridOpacity()));
 	p.setColor(group.readEntry("MinorGridColor",(QColor) this->minorGridPen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("MinorGridStyle",(int) this->minorGridPen().style()));
 	p.setWidthF(group.readEntry("MinorGridWidth", this->minorGridPen().widthF()));
 	this->setMinorGridPen(p);
 	p.setColor(group.readEntry("MinorTicksColor",(QColor) this->minorTicksPen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("MinorTicksLineStyle",(int) this->minorTicksPen().style()));
 	p.setWidthF(group.readEntry("MinorTicksWidth", this->minorTicksPen().widthF()));
 	this->setMinorTicksPen(p);
 	this->setMinorTicksOpacity(group.readEntry("MinorTicksOpacity",this->minorTicksOpacity()));
 
 	const QVector<TextLabel*>& childElements = children<TextLabel>(AbstractAspect::IncludeHidden);
 	for (auto* child : childElements)
 		child->loadThemeConfig(config);
 }
 
 void Axis::saveThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("Axis");
 
 	// Tick label
 	group.writeEntry("LabelsFontColor", (QColor) this->labelsColor());
 	group.writeEntry("LabelsOpacity", this->labelsOpacity());
 
 	//Line
 	group.writeEntry("LineOpacity", this->lineOpacity());
 	group.writeEntry("LineColor", (QColor) this->linePen().color());
 	group.writeEntry("LineStyle", (int) this->linePen().style());
 	group.writeEntry("LineWidth", this->linePen().widthF());
 
 	//Major ticks
 	group.writeEntry("MajorGridOpacity", this->majorGridOpacity());
 	group.writeEntry("MajorGridColor", (QColor) this->majorGridPen().color());
 	group.writeEntry("MajorGridStyle", (int) this->majorGridPen().style());
 	group.writeEntry("MajorGridWidth", this->majorGridPen().widthF());
 	group.writeEntry("MajorTicksColor", (QColor)this->majorTicksPen().color());
 	group.writeEntry("MajorTicksLineStyle", (int) this->majorTicksPen().style());
 	group.writeEntry("MajorTicksWidth", this->majorTicksPen().widthF());
 	group.writeEntry("MajorTicksOpacity", this->majorTicksOpacity());
 	group.writeEntry("MajorTicksType", (int)this->majorTicksType());
 
 	//Minor ticks
 	group.writeEntry("MinorGridOpacity", this->minorGridOpacity());
 	group.writeEntry("MinorGridColor",(QColor) this->minorGridPen().color());
 	group.writeEntry("MinorGridStyle", (int) this->minorGridPen().style());
 	group.writeEntry("MinorGridWidth", this->minorGridPen().widthF());
 	group.writeEntry("MinorTicksColor", (QColor) this->minorTicksPen().color());
 	group.writeEntry("MinorTicksLineStyle",( int) this->minorTicksPen().style());
 	group.writeEntry("MinorTicksWidth", this->minorTicksPen().widthF());
 	group.writeEntry("MinorTicksOpacity", this->minorTicksOpacity());
 	group.writeEntry("MinorTicksType", (int)this->minorTicksType());
 
 	const QVector<TextLabel*>& childElements = children<TextLabel>(AbstractAspect::IncludeHidden);
 	childElements.at(0)->saveThemeConfig(config);
 }
diff --git a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
index 8f9fdc348..b1c55741b 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
@@ -1,3155 +1,3155 @@
 /***************************************************************************
 	File                 : CartesianPlot.cpp
 	Project              : LabPlot
 	Description          : Cartesian plot
 	--------------------------------------------------------------------
 	Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
 	Copyright            : (C) 2016-2018 by Stefan Gerlach (stefan.gerlach@uni.kn)
 	Copyright            : (C) 2017-2018 by Garvit Khatri (garvitdelhi@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 "CartesianPlot.h"
 #include "CartesianPlotPrivate.h"
 #include "Axis.h"
 #include "XYCurve.h"
 #include "Histogram.h"
 #include "XYEquationCurve.h"
 #include "XYDataReductionCurve.h"
 #include "XYDifferentiationCurve.h"
 #include "XYIntegrationCurve.h"
 #include "XYInterpolationCurve.h"
 #include "XYSmoothCurve.h"
 #include "XYFitCurve.h"
 #include "XYFourierFilterCurve.h"
 #include "XYFourierTransformCurve.h"
 #include "XYConvolutionCurve.h"
 #include "XYCorrelationCurve.h"
 #include "backend/core/Project.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlotLegend.h"
 #include "backend/worksheet/plots/cartesian/CustomPoint.h"
 #include "backend/worksheet/plots/PlotArea.h"
 #include "backend/worksheet/plots/AbstractPlotPrivate.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/macros.h"
 #include "backend/lib/trace.h"
 #include "kdefrontend/spreadsheet/PlotDataDialog.h" //for PlotDataDialog::AnalysisAction. TODO: find a better place for this enum.
 #include "kdefrontend/ThemeHandler.h"
 #include "kdefrontend/widgets/ThemesWidget.h"
 
 #include <QDir>
 #include <QDropEvent>
 #include <QIcon>
 #include <QMenu>
 #include <QMimeData>
 #include <QPainter>
 #include <QToolBar>
 #include <QWidgetAction>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 /**
  * \class CartesianPlot
  * \brief A xy-plot.
  *
  *
  */
 CartesianPlot::CartesianPlot(const QString &name):AbstractPlot(name, new CartesianPlotPrivate(this)),
 	m_legend(nullptr), m_zoomFactor(1.2), m_menusInitialized(false),
 	addNewMenu(nullptr), zoomMenu(nullptr), dataAnalysisMenu(nullptr), themeMenu(nullptr) {
 	init();
 }
 
 CartesianPlot::CartesianPlot(const QString &name, CartesianPlotPrivate *dd):AbstractPlot(name, dd),
 	m_legend(nullptr), m_zoomFactor(1.2),
 	addNewMenu(nullptr), zoomMenu(nullptr), dataAnalysisMenu(nullptr), themeMenu(nullptr) {
 	init();
 }
 
 CartesianPlot::~CartesianPlot() {
 	if (m_menusInitialized) {
 		delete addNewMenu;
 		delete zoomMenu;
 		delete themeMenu;
 	}
 
 	delete m_coordinateSystem;
 
 	//don't need to delete objects added with addChild()
 
 	//no need to delete the d-pointer here - it inherits from QGraphicsItem
 	//and is deleted during the cleanup in QGraphicsScene
 }
 
 /*!
 	initializes all member variables of \c CartesianPlot
 */
 void CartesianPlot::init() {
 	Q_D(CartesianPlot);
 
 	d->cSystem = new CartesianCoordinateSystem(this);
 	m_coordinateSystem = d->cSystem;
 
 	d->rangeType = CartesianPlot::RangeFree;
 	d->xRangeFormat = CartesianPlot::Numeric;
 	d->yRangeFormat = CartesianPlot::Numeric;
 	d->xRangeDateTimeFormat = "yyyy-MM-dd hh:mm:ss";
 	d->yRangeDateTimeFormat = "yyyy-MM-dd hh:mm:ss";
 	d->rangeLastValues = 1000;
 	d->rangeFirstValues = 1000;
 	d->autoScaleX = true;
 	d->autoScaleY = true;
 	d->xScale = ScaleLinear;
 	d->yScale = ScaleLinear;
 	d->xRangeBreakingEnabled = false;
 	d->yRangeBreakingEnabled = false;
 
 	//the following factor determines the size of the offset between the min/max points of the curves
 	//and the coordinate system ranges, when doing auto scaling
 	//Factor 0 corresponds to the exact match - min/max values of the curves correspond to the start/end values of the ranges.
 	//TODO: make this factor optional.
 	//Provide in the UI the possibility to choose between "exact" or 0% offset, 2%, 5% and 10% for the auto fit option
 	d->autoScaleOffsetFactor = 0.0f;
 
 	m_plotArea = new PlotArea(name() + " plot area");
 	addChildFast(m_plotArea);
 
 	//Plot title
 	m_title = new TextLabel(this->name(), TextLabel::PlotTitle);
 	addChild(m_title);
 	m_title->setHidden(true);
 	m_title->setParentGraphicsItem(m_plotArea->graphicsItem());
 
 	//offset between the plot area and the area defining the coordinate system, in scene units.
 	d->horizontalPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->verticalPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 
 	connect(this, SIGNAL(aspectAdded(const AbstractAspect*)), this, SLOT(childAdded(const AbstractAspect*)));
 	connect(this, SIGNAL(aspectRemoved(const AbstractAspect*,const AbstractAspect*,const AbstractAspect*)),
 	        this, SLOT(childRemoved(const AbstractAspect*,const AbstractAspect*,const AbstractAspect*)));
 
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsSelectable, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsFocusable, true);
 }
 
 /*!
 	initializes all children of \c CartesianPlot and
 	setups a default plot of type \c type with a plot title.
 */
 void CartesianPlot::initDefault(Type type) {
 	Q_D(CartesianPlot);
 
 	switch (type) {
 	case FourAxes: {
 			d->xMin = 0;
 			d->xMax = 1;
 			d->yMin = 0;
 			d->yMax = 1;
 
 			//Axes
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisBottom);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			QPen pen = axis->majorGridPen();
 			pen.setStyle(Qt::SolidLine);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::DotLine);
 			axis->setMinorGridPen(pen);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("x axis 2", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisTop);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			axis->setLabelsPosition(Axis::NoLabels);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisLeft);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			pen = axis->majorGridPen();
 			pen.setStyle(Qt::SolidLine);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::DotLine);
 			axis->setMinorGridPen(pen);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 2", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisRight);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setOffset(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			axis->setLabelsPosition(Axis::NoLabels);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxes: {
 			d->xMin = 0;
 			d->xMax = 1;
 			d->yMin = 0;
 			d->yMax = 1;
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisBottom);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisLeft);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxesCentered: {
 			d->xMin = -0.5;
 			d->xMax = 0.5;
 			d->yMin = -0.5;
 			d->yMax = 0.5;
 
 			d->horizontalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 			d->verticalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 
 			QPen pen = m_plotArea->borderPen();
 			pen.setStyle(Qt::NoPen);
 			m_plotArea->setBorderPen(pen);
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCentered);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCentered);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxesCenteredZero: {
 			d->xMin = -0.5;
 			d->xMax = 0.5;
 			d->yMin = -0.5;
 			d->yMax = 0.5;
 
 			d->horizontalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 			d->verticalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 
 			QPen pen = m_plotArea->borderPen();
 			pen.setStyle(Qt::NoPen);
 			m_plotArea->setBorderPen(pen);
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCustom);
 			axis->setOffset(0);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCustom);
 			axis->setOffset(0);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	}
 
 	d->xMinPrev = d->xMin;
 	d->xMaxPrev = d->xMax;
 	d->yMinPrev = d->yMin;
 	d->yMaxPrev = d->yMax;
 
 	//Geometry, specify the plot rect in scene coordinates.
 	//TODO: Use default settings for left, top, width, height and for min/max for the coordinate system
 	float x = Worksheet::convertToSceneUnits(2, Worksheet::Centimeter);
 	float y = Worksheet::convertToSceneUnits(2, Worksheet::Centimeter);
 	float w = Worksheet::convertToSceneUnits(10, Worksheet::Centimeter);
 	float h = Worksheet::convertToSceneUnits(10, Worksheet::Centimeter);
 
 	//all plot children are initialized -> set the geometry of the plot in scene coordinates.
 	d->rect = QRectF(x,y,w,h);
 }
 
 void CartesianPlot::initActions() {
 	//"add new" actions
 	addCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("xy-curve"), this);
 	addHistogramPlot = new QAction(QIcon::fromTheme("labplot-xy-fourier_filter-curve"), i18n("Histogram"), this);
 	addEquationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-equation-curve"), i18n("xy-curve from a mathematical equation"), this);
 // no icons yet
 	addDataReductionCurveAction = new QAction(i18n("xy-curve from a data reduction"), this);
 	addDifferentiationCurveAction = new QAction(i18n("xy-curve from a differentiation"), this);
 	addIntegrationCurveAction = new QAction(i18n("xy-curve from an integration"), this);
 	addInterpolationCurveAction = new QAction(i18n("xy-curve from an interpolation"), this);
 	addSmoothCurveAction = new QAction(i18n("xy-curve from a smooth"), this);
 	addFitCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("xy-curve from a fit to data"), this);
 	addFourierFilterCurveAction = new QAction(i18n("xy-curve from a Fourier filter"), this);
 	addFourierTransformCurveAction = new QAction(i18n("xy-curve from a Fourier transform"), this);
 	addConvolutionCurveAction = new QAction(i18n("xy-curve from a (de-)convolution"), this);
 	addCorrelationCurveAction = new QAction(i18n("xy-curve from a correlation"), this);
 //	addInterpolationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("xy-curve from an interpolation"), this);
 //	addSmoothCurveAction = new QAction(QIcon::fromTheme("labplot-xy-smooth-curve"), i18n("xy-curve from a smooth"), this);
 //	addFourierFilterCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier_filter-curve"), i18n("xy-curve from a Fourier filter"), this);
 //	addFourierTransformCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier_transform-curve"), i18n("xy-curve from a Fourier transform"), this);
 //	addConvolutionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-convolution-curve"), i18n("xy-curve from a (de-)convolution"), this);
 //	addCorrelationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-correlation-curve"), i18n("xy-curve from a correlation"), this);
 	addLegendAction = new QAction(QIcon::fromTheme("text-field"), i18n("Legend"), this);
 	if (children<CartesianPlotLegend>().size()>0)
 		addLegendAction->setEnabled(false);	//only one legend is allowed -> disable the action
 
 	addHorizontalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-horizontal"), i18n("Horizontal Axis"), this);
 	addVerticalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-vertical"), i18n("Vertical Axis"), this);
 	addTextLabelAction = new QAction(QIcon::fromTheme("draw-text"), i18n("Text Label"), this);
 	addCustomPointAction = new QAction(QIcon::fromTheme("draw-cross"), i18n("Custom Point"), this);
 
 	connect(addCurveAction, SIGNAL(triggered()), SLOT(addCurve()));
 	connect(addHistogramPlot,SIGNAL(triggered()), SLOT(addHistogram()));
 	connect(addEquationCurveAction, SIGNAL(triggered()), SLOT(addEquationCurve()));
 	connect(addDataReductionCurveAction, SIGNAL(triggered()), SLOT(addDataReductionCurve()));
 	connect(addDifferentiationCurveAction, SIGNAL(triggered()), SLOT(addDifferentiationCurve()));
 	connect(addIntegrationCurveAction, SIGNAL(triggered()), SLOT(addIntegrationCurve()));
 	connect(addInterpolationCurveAction, SIGNAL(triggered()), SLOT(addInterpolationCurve()));
 	connect(addSmoothCurveAction, SIGNAL(triggered()), SLOT(addSmoothCurve()));
 	connect(addFitCurveAction, SIGNAL(triggered()), SLOT(addFitCurve()));
 	connect(addFourierFilterCurveAction, SIGNAL(triggered()), SLOT(addFourierFilterCurve()));
 	connect(addFourierTransformCurveAction, SIGNAL(triggered()), SLOT(addFourierTransformCurve()));
 	connect(addConvolutionCurveAction, SIGNAL(triggered()), SLOT(addConvolutionCurve()));
 	connect(addCorrelationCurveAction, SIGNAL(triggered()), SLOT(addCorrelationCurve()));
 
 	connect(addLegendAction, SIGNAL(triggered()), SLOT(addLegend()));
 	connect(addHorizontalAxisAction, SIGNAL(triggered()), SLOT(addHorizontalAxis()));
 	connect(addVerticalAxisAction, SIGNAL(triggered()), SLOT(addVerticalAxis()));
 	connect(addTextLabelAction, SIGNAL(triggered()), SLOT(addTextLabel()));
 	connect(addCustomPointAction, SIGNAL(triggered()), SLOT(addCustomPoint()));
 
 	//Analysis menu actions
 	addDataOperationAction = new QAction(i18n("Data Operation"), this);
 	addDataReductionAction = new QAction(i18n("Reduce Data"), this);
 	addDifferentiationAction = new QAction(i18n("Differentiate"), this);
 	addIntegrationAction = new QAction(i18n("Integrate"), this);
 	addInterpolationAction = new QAction(i18n("Interpolate"), this);
 	addSmoothAction = new QAction(i18n("Smooth"), this);
 	addConvolutionAction = new QAction(i18n("Convolute/Deconvolute"), this);
 	addCorrelationAction = new QAction(i18n("Correlation"), this);
 
 	QAction* fitAction = new QAction(i18n("Linear"), this);
 	fitAction->setData(PlotDataDialog::FitLinear);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Power"), this);
 	fitAction->setData(PlotDataDialog::FitPower);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Exponential (degree 1)"), this);
 	fitAction->setData(PlotDataDialog::FitExp1);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Exponential (degree 2)"), this);
 	fitAction->setData(PlotDataDialog::FitExp2);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Inverse exponential"), this);
 	fitAction->setData(PlotDataDialog::FitInvExp);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Gauss"), this);
 	fitAction->setData(PlotDataDialog::FitGauss);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Cauchy-Lorentz"), this);
 	fitAction->setData(PlotDataDialog::FitCauchyLorentz);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Arc Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTan);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Hyperbolic Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTanh);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Error Function"), this);
 	fitAction->setData(PlotDataDialog::FitErrFunc);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Custom"), this);
 	fitAction->setData(PlotDataDialog::FitCustom);
 	addFitAction.append(fitAction);
 
 	addFourierFilterAction = new QAction(i18n("Fourier Filter"), this);
 
 	connect(addDataReductionAction, SIGNAL(triggered()), SLOT(addDataReductionCurve()));
 	connect(addDifferentiationAction, SIGNAL(triggered()), SLOT(addDifferentiationCurve()));
 	connect(addIntegrationAction, SIGNAL(triggered()), SLOT(addIntegrationCurve()));
 	connect(addInterpolationAction, SIGNAL(triggered()), SLOT(addInterpolationCurve()));
 	connect(addSmoothAction, SIGNAL(triggered()), SLOT(addSmoothCurve()));
 	connect(addConvolutionAction, SIGNAL(triggered()), SLOT(addConvolutionCurve()));
 	connect(addCorrelationAction, SIGNAL(triggered()), SLOT(addCorrelationCurve()));
-	for (const auto& action: addFitAction)
+	for (const auto& action : addFitAction)
 		connect(action, SIGNAL(triggered()), SLOT(addFitCurve()));
 	connect(addFourierFilterAction, SIGNAL(triggered()), SLOT(addFourierFilterCurve()));
 
 	//zoom/navigate actions
 	scaleAutoAction = new QAction(QIcon::fromTheme("labplot-auto-scale-all"), i18n("Auto Scale"), this);
 	scaleAutoXAction = new QAction(QIcon::fromTheme("labplot-auto-scale-x"), i18n("Auto Scale X"), this);
 	scaleAutoYAction = new QAction(QIcon::fromTheme("labplot-auto-scale-y"), i18n("Auto Scale Y"), this);
 	zoomInAction = new QAction(QIcon::fromTheme("zoom-in"), i18n("Zoom In"), this);
 	zoomOutAction = new QAction(QIcon::fromTheme("zoom-out"), i18n("Zoom Out"), this);
 	zoomInXAction = new QAction(QIcon::fromTheme("labplot-zoom-in-x"), i18n("Zoom In X"), this);
 	zoomOutXAction = new QAction(QIcon::fromTheme("labplot-zoom-out-x"), i18n("Zoom Out X"), this);
 	zoomInYAction = new QAction(QIcon::fromTheme("labplot-zoom-in-y"), i18n("Zoom In Y"), this);
 	zoomOutYAction = new QAction(QIcon::fromTheme("labplot-zoom-out-y"), i18n("Zoom Out Y"), this);
 	shiftLeftXAction = new QAction(QIcon::fromTheme("labplot-shift-left-x"), i18n("Shift Left X"), this);
 	shiftRightXAction = new QAction(QIcon::fromTheme("labplot-shift-right-x"), i18n("Shift Right X"), this);
 	shiftUpYAction = new QAction(QIcon::fromTheme("labplot-shift-up-y"), i18n("Shift Up Y"), this);
 	shiftDownYAction = new QAction(QIcon::fromTheme("labplot-shift-down-y"), i18n("Shift Down Y"), this);
 
 	connect(scaleAutoAction, SIGNAL(triggered()), SLOT(scaleAuto()));
 	connect(scaleAutoXAction, SIGNAL(triggered()), SLOT(scaleAutoX()));
 	connect(scaleAutoYAction, SIGNAL(triggered()), SLOT(scaleAutoY()));
 	connect(zoomInAction, SIGNAL(triggered()), SLOT(zoomIn()));
 	connect(zoomOutAction, SIGNAL(triggered()), SLOT(zoomOut()));
 	connect(zoomInXAction, SIGNAL(triggered()), SLOT(zoomInX()));
 	connect(zoomOutXAction, SIGNAL(triggered()), SLOT(zoomOutX()));
 	connect(zoomInYAction, SIGNAL(triggered()), SLOT(zoomInY()));
 	connect(zoomOutYAction, SIGNAL(triggered()), SLOT(zoomOutY()));
 	connect(shiftLeftXAction, SIGNAL(triggered()), SLOT(shiftLeftX()));
 	connect(shiftRightXAction, SIGNAL(triggered()), SLOT(shiftRightX()));
 	connect(shiftUpYAction, SIGNAL(triggered()), SLOT(shiftUpY()));
 	connect(shiftDownYAction, SIGNAL(triggered()), SLOT(shiftDownY()));
 
 	//visibility action
 	visibilityAction = new QAction(i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, SIGNAL(triggered()), this, SLOT(visibilityChanged()));
 }
 
 void CartesianPlot::initMenus() {
 	initActions();
 
 	addNewMenu = new QMenu(i18n("Add New"));
 	addNewMenu->addAction(addCurveAction);
 	addNewMenu->addAction(addHistogramPlot);
 	addNewMenu->addAction(addEquationCurveAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addDataReductionCurveAction);
 	addNewMenu->addAction(addDifferentiationCurveAction);
 	addNewMenu->addAction(addIntegrationCurveAction);
 	addNewMenu->addAction(addInterpolationCurveAction);
 	addNewMenu->addAction(addSmoothCurveAction);
 	addNewMenu->addAction(addFitCurveAction);
 	addNewMenu->addAction(addFourierFilterCurveAction);
 	addNewMenu->addAction(addFourierTransformCurveAction);
 	addNewMenu->addAction(addConvolutionCurveAction);
 	addNewMenu->addAction(addCorrelationCurveAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addLegendAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addHorizontalAxisAction);
 	addNewMenu->addAction(addVerticalAxisAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addTextLabelAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addCustomPointAction);
 
 	zoomMenu = new QMenu(i18n("Zoom"));
 	zoomMenu->addAction(scaleAutoAction);
 	zoomMenu->addAction(scaleAutoXAction);
 	zoomMenu->addAction(scaleAutoYAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInAction);
 	zoomMenu->addAction(zoomOutAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInXAction);
 	zoomMenu->addAction(zoomOutXAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInYAction);
 	zoomMenu->addAction(zoomOutYAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(shiftLeftXAction);
 	zoomMenu->addAction(shiftRightXAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(shiftUpYAction);
 	zoomMenu->addAction(shiftDownYAction);
 
 	// Data manipulation menu
 	QMenu* dataManipulationMenu = new QMenu(i18n("Data Manipulation"));
 	dataManipulationMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	dataManipulationMenu->addAction(addDataOperationAction);
 	dataManipulationMenu->addAction(addDataReductionAction);
 
 	// Data fit menu
 	QMenu* dataFitMenu = new QMenu(i18n("Fit"));
 	dataFitMenu->setIcon(QIcon::fromTheme("labplot-xy-fit-curve"));
 	dataFitMenu->addAction(addFitAction.at(0));
 	dataFitMenu->addAction(addFitAction.at(1));
 	dataFitMenu->addAction(addFitAction.at(2));
 	dataFitMenu->addAction(addFitAction.at(3));
 	dataFitMenu->addAction(addFitAction.at(4));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(5));
 	dataFitMenu->addAction(addFitAction.at(6));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(7));
 	dataFitMenu->addAction(addFitAction.at(8));
 	dataFitMenu->addAction(addFitAction.at(9));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(10));
 
 	//analysis menu
 	dataAnalysisMenu = new QMenu(i18n("Analysis"));
 	dataAnalysisMenu->insertMenu(nullptr, dataManipulationMenu);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addDifferentiationAction);
 	dataAnalysisMenu->addAction(addIntegrationAction);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addInterpolationAction);
 	dataAnalysisMenu->addAction(addSmoothAction);
 	dataAnalysisMenu->addAction(addFourierFilterAction);
 	dataAnalysisMenu->addAction(addConvolutionAction);
 	dataAnalysisMenu->addAction(addCorrelationAction);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addMenu(dataFitMenu);
 
 	//themes menu
 	themeMenu = new QMenu(i18n("Apply Theme"));
 	ThemesWidget* themeWidget = new ThemesWidget(nullptr);
 	connect(themeWidget, SIGNAL(themeSelected(QString)), this, SLOT(loadTheme(QString)));
 	connect(themeWidget, SIGNAL(themeSelected(QString)), themeMenu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(themeWidget);
 	themeMenu->addAction(widgetAction);
 
 	m_menusInitialized = true;
 }
 
 QMenu* CartesianPlot::createContextMenu() {
 	if (!m_menusInitialized)
 		initMenus();
 
 	QMenu* menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1);
 
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 
 	menu->insertMenu(firstAction, addNewMenu);
 	menu->insertMenu(firstAction, zoomMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, themeMenu);
 	menu->insertSeparator(firstAction);
 
 	return menu;
 }
 
 QMenu* CartesianPlot::analysisMenu() {
 	if (!m_menusInitialized)
 		initMenus();
 
 	return dataAnalysisMenu;
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon CartesianPlot::icon() const {
 	return QIcon::fromTheme("office-chart-line");
 }
 
 QVector<AbstractAspect*> CartesianPlot::dependsOn() const {
 	//aspects which the plotted data in the worksheet depends on (spreadsheets and later matrices)
 	QVector<AbstractAspect*> aspects;
 
 	for (const auto* curve : children<XYCurve>()) {
 		if (curve->xColumn() && dynamic_cast<Spreadsheet*>(curve->xColumn()->parentAspect()) )
 			aspects << curve->xColumn()->parentAspect();
 
 		if (curve->yColumn() && dynamic_cast<Spreadsheet*>(curve->yColumn()->parentAspect()) )
 			aspects << curve->yColumn()->parentAspect();
 	}
 
 	return aspects;
 }
 
 void CartesianPlot::navigate(CartesianPlot::NavigationOperation op) {
 	if (op == ScaleAuto) scaleAuto();
 	else if (op == ScaleAutoX) scaleAutoX();
 	else if (op == ScaleAutoY) scaleAutoY();
 	else if (op == ZoomIn) zoomIn();
 	else if (op == ZoomOut) zoomOut();
 	else if (op == ZoomInX) zoomInX();
 	else if (op == ZoomOutX) zoomOutX();
 	else if (op == ZoomInY) zoomInY();
 	else if (op == ZoomOutY) zoomOutY();
 	else if (op == ShiftLeftX) shiftLeftX();
 	else if (op == ShiftRightX) shiftRightX();
 	else if (op == ShiftUpY) shiftUpY();
 	else if (op == ShiftDownY) shiftDownY();
 }
 
 void CartesianPlot::setSuppressDataChangedSignal(bool value) {
 	Q_D(CartesianPlot);
 	d->suppressRetransform = value;
 }
 
 void CartesianPlot::processDropEvent(QDropEvent* event) {
 	PERFTRACE("CartesianPlot::processDropEvent");
 	const QMimeData* mimeData = event->mimeData();
 	if (!mimeData)
 		return;
 
 	//deserialize the mime data to the vector of aspect pointers
 	QByteArray data = mimeData->data(QLatin1String("labplot-dnd"));
 	QVector<quintptr> vec;
 	QDataStream stream(&data, QIODevice::ReadOnly);
 	stream >> vec;
 	QVector<AbstractColumn*> columns;
 	for (auto i : vec) {
 		AbstractAspect* aspect = (AbstractAspect*)i;
 		AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 		if (column)
 			columns << column;
 	}
 
 	//return if there are no columns being dropped.
 	//TODO: extend this later when we allow to drag&drop plots, etc.
 	if (columns.isEmpty())
 		return;
 
 	//determine the first column with "x plot designation" as the x-data column for all curves to be created
 	const AbstractColumn* xColumn = nullptr;
 	for (const auto* column : columns) {
 		if (column->plotDesignation() == AbstractColumn::X) {
 			xColumn = column;
 			break;
 		}
 	}
 
 	//if no column with "x plot designation" is available, use the x-data column of the first curve in the plot,
 	if (xColumn == nullptr) {
 		QVector<XYCurve*> curves = children<XYCurve>();
 		if (!curves.isEmpty())
 			xColumn = curves.at(0)->xColumn();
 	}
 
 	//use the first dropped column if no column with "x plot designation" nor curves are available
 	if (xColumn == nullptr)
 		xColumn = columns.at(0);
 
 	//create curves
 	bool curvesAdded = false;
 	for (const auto* column : columns) {
 		if (column == xColumn)
 			continue;
 
 		XYCurve* curve = new XYCurve(column->name());
 		curve->suppressRetransform(true); //suppress retransform, all curved will be recalculated at the end
 		curve->setXColumn(xColumn);
 		curve->setYColumn(column);
 		addChild(curve);
 		curve->suppressRetransform(false);
 		curvesAdded = true;
 	}
 
 	if (curvesAdded)
 		dataChanged();
 }
 
 
 bool CartesianPlot::isPanningActive() const {
 	Q_D(const CartesianPlot);
 	return d->panningStarted;
 }
 
 //##############################################################################
 //################################  getter methods  ############################
 //##############################################################################
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeType, rangeType, rangeType)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeFormat, xRangeFormat, xRangeFormat)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeFormat, yRangeFormat, yRangeFormat)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, int, rangeLastValues, rangeLastValues)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, int, rangeFirstValues, rangeFirstValues)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, autoScaleX, autoScaleX)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, xMin, xMin)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, xMax, xMax)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::Scale, xScale, xScale)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, xRangeBreakingEnabled, xRangeBreakingEnabled)
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeBreaks, xRangeBreaks, xRangeBreaks)
 
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, autoScaleY, autoScaleY)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, yMin, yMin)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, yMax, yMax)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::Scale, yScale, yScale)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, yRangeBreakingEnabled, yRangeBreakingEnabled)
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeBreaks, yRangeBreaks, yRangeBreaks)
 
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, QString, theme, theme)
 
 /*!
 	returns the actual bounding rectangular of the plot area showing data (plot's rectangular minus padding)
 	in plot's coordinates
  */
 QRectF CartesianPlot::dataRect() const {
 	Q_D(const CartesianPlot);
 	return d->dataRect;
 }
 
 CartesianPlot::MouseMode CartesianPlot::mouseMode() const {
 	Q_D(const CartesianPlot);
 	return d->mouseMode;
 }
 
 const QString& CartesianPlot::xRangeDateTimeFormat() const {
 	Q_D(const CartesianPlot);
 	return d->xRangeDateTimeFormat;
 }
 
 const QString& CartesianPlot::yRangeDateTimeFormat() const {
 	Q_D(const CartesianPlot);
 	return d->yRangeDateTimeFormat;
 }
 
 //##############################################################################
 //######################  setter methods and undo commands  ####################
 //##############################################################################
 /*!
 	set the rectangular, defined in scene coordinates
  */
 class CartesianPlotSetRectCmd : public QUndoCommand {
 public:
 	CartesianPlotSetRectCmd(CartesianPlotPrivate* private_obj, QRectF rect) : m_private(private_obj), m_rect(rect) {
 		setText(i18n("%1: change geometry rect", m_private->name()));
 	};
 
 	void redo() override {
 		QRectF tmp = m_private->rect;
 		//TODO:
 // 		const double horizontalRatio = m_rect.width() / m_private->rect.width();
 // 		const double verticalRatio = m_rect.height() / m_private->rect.height();
 // 		m_private->q->handleResize(horizontalRatio, verticalRatio, false);
 		m_private->rect = m_rect;
 		m_rect = tmp;
 		m_private->retransform();
 		emit m_private->q->rectChanged(m_private->rect);
 	};
 
 	void undo() override {
 		redo();
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	QRectF m_rect;
 };
 
 void CartesianPlot::setRect(const QRectF& rect) {
 	Q_D(CartesianPlot);
 	if (rect != d->rect)
 		exec(new CartesianPlotSetRectCmd(d, rect));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeType, CartesianPlot::RangeType, rangeType, rangeChanged);
 void CartesianPlot::setRangeType(RangeType type) {
 	Q_D(CartesianPlot);
 	if (type != d->rangeType)
 		exec(new CartesianPlotSetRangeTypeCmd(d, type, ki18n("%1: set range type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeFormat, CartesianPlot::RangeFormat, xRangeFormat, xRangeFormatChanged);
 void CartesianPlot::setXRangeFormat(RangeFormat format) {
 	Q_D(CartesianPlot);
 	if (format != d->xRangeFormat)
 		exec(new CartesianPlotSetXRangeFormatCmd(d, format, ki18n("%1: set x-range format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeFormat, CartesianPlot::RangeFormat, yRangeFormat, yRangeFormatChanged);
 void CartesianPlot::setYRangeFormat(RangeFormat format) {
 	Q_D(CartesianPlot);
 	if (format != d->yRangeFormat)
 		exec(new CartesianPlotSetYRangeFormatCmd(d, format, ki18n("%1: set y-range format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeLastValues, int, rangeLastValues, rangeChanged);
 void CartesianPlot::setRangeLastValues(int values) {
 	Q_D(CartesianPlot);
 	if (values != d->rangeLastValues)
 		exec(new CartesianPlotSetRangeLastValuesCmd(d, values, ki18n("%1: set range")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeFirstValues, int, rangeFirstValues, rangeChanged);
 void CartesianPlot::setRangeFirstValues(int values) {
 	Q_D(CartesianPlot);
 	if (values != d->rangeFirstValues)
 		exec(new CartesianPlotSetRangeFirstValuesCmd(d, values, ki18n("%1: set range")));
 }
 
 
 class CartesianPlotSetAutoScaleXCmd : public QUndoCommand {
 public:
 	CartesianPlotSetAutoScaleXCmd(CartesianPlotPrivate* private_obj, bool autoScale) :
 		m_private(private_obj), m_autoScale(autoScale), m_autoScaleOld(false), m_minOld(0.0), m_maxOld(0.0) {
 		setText(i18n("%1: change x-range auto scaling", m_private->name()));
 	};
 
 	void redo() override {
 		m_autoScaleOld = m_private->autoScaleX;
 		if (m_autoScale) {
 			m_minOld = m_private->xMin;
 			m_maxOld = m_private->xMax;
 			m_private->q->scaleAutoX();
 		}
 		m_private->autoScaleX = m_autoScale;
 		emit m_private->q->xAutoScaleChanged(m_autoScale);
 	};
 
 	void undo() override {
 		if (!m_autoScaleOld) {
 			m_private->xMin = m_minOld;
 			m_private->xMax = m_maxOld;
 			m_private->retransformScales();
 		}
 		m_private->autoScaleX = m_autoScaleOld;
 		emit m_private->q->xAutoScaleChanged(m_autoScaleOld);
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	bool m_autoScale;
 	bool m_autoScaleOld;
 	double m_minOld;
 	double m_maxOld;
 };
 
 void CartesianPlot::setAutoScaleX(bool autoScaleX) {
 	Q_D(CartesianPlot);
 	if (autoScaleX != d->autoScaleX)
 		exec(new CartesianPlotSetAutoScaleXCmd(d, autoScaleX));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXMin, double, xMin, retransformScales)
 void CartesianPlot::setXMin(double xMin) {
 	Q_D(CartesianPlot);
 	if (xMin != d->xMin)
 		exec(new CartesianPlotSetXMinCmd(d, xMin, ki18n("%1: set min x")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXMax, double, xMax, retransformScales)
 void CartesianPlot::setXMax(double xMax) {
 	Q_D(CartesianPlot);
 	if (xMax != d->xMax)
 		exec(new CartesianPlotSetXMaxCmd(d, xMax, ki18n("%1: set max x")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXScale, CartesianPlot::Scale, xScale, retransformScales)
 void CartesianPlot::setXScale(Scale scale) {
 	Q_D(CartesianPlot);
 	if (scale != d->xScale)
 		exec(new CartesianPlotSetXScaleCmd(d, scale, ki18n("%1: set x scale")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeBreakingEnabled, bool, xRangeBreakingEnabled, retransformScales)
 void CartesianPlot::setXRangeBreakingEnabled(bool enabled) {
 	Q_D(CartesianPlot);
 	if (enabled != d->xRangeBreakingEnabled)
 		exec(new CartesianPlotSetXRangeBreakingEnabledCmd(d, enabled, ki18n("%1: x-range breaking enabled")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeBreaks, CartesianPlot::RangeBreaks, xRangeBreaks, retransformScales)
 void CartesianPlot::setXRangeBreaks(const RangeBreaks& breakings) {
 	Q_D(CartesianPlot);
 	exec(new CartesianPlotSetXRangeBreaksCmd(d, breakings, ki18n("%1: x-range breaks changed")));
 }
 
 class CartesianPlotSetAutoScaleYCmd : public QUndoCommand {
 public:
 	CartesianPlotSetAutoScaleYCmd(CartesianPlotPrivate* private_obj, bool autoScale) :
 		m_private(private_obj), m_autoScale(autoScale), m_autoScaleOld(false), m_minOld(0.0), m_maxOld(0.0) {
 		setText(i18n("%1: change y-range auto scaling", m_private->name()));
 	};
 
 	void redo() override {
 		m_autoScaleOld = m_private->autoScaleY;
 		if (m_autoScale) {
 			m_minOld = m_private->yMin;
 			m_maxOld = m_private->yMax;
 			m_private->q->scaleAutoY();
 		}
 		m_private->autoScaleY = m_autoScale;
 		emit m_private->q->yAutoScaleChanged(m_autoScale);
 	};
 
 	void undo() override {
 		if (!m_autoScaleOld) {
 			m_private->yMin = m_minOld;
 			m_private->yMax = m_maxOld;
 			m_private->retransformScales();
 		}
 		m_private->autoScaleY = m_autoScaleOld;
 		emit m_private->q->yAutoScaleChanged(m_autoScaleOld);
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	bool m_autoScale;
 	bool m_autoScaleOld;
 	double m_minOld;
 	double m_maxOld;
 };
 
 void CartesianPlot::setAutoScaleY(bool autoScaleY) {
 	Q_D(CartesianPlot);
 	if (autoScaleY != d->autoScaleY)
 		exec(new CartesianPlotSetAutoScaleYCmd(d, autoScaleY));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYMin, double, yMin, retransformScales)
 void CartesianPlot::setYMin(double yMin) {
 	Q_D(CartesianPlot);
 	if (yMin != d->yMin)
 		exec(new CartesianPlotSetYMinCmd(d, yMin, ki18n("%1: set min y")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYMax, double, yMax, retransformScales)
 void CartesianPlot::setYMax(double yMax) {
 	Q_D(CartesianPlot);
 	if (yMax != d->yMax)
 		exec(new CartesianPlotSetYMaxCmd(d, yMax, ki18n("%1: set max y")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYScale, CartesianPlot::Scale, yScale, retransformScales)
 void CartesianPlot::setYScale(Scale scale) {
 	Q_D(CartesianPlot);
 	if (scale != d->yScale)
 		exec(new CartesianPlotSetYScaleCmd(d, scale, ki18n("%1: set y scale")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeBreakingEnabled, bool, yRangeBreakingEnabled, retransformScales)
 void CartesianPlot::setYRangeBreakingEnabled(bool enabled) {
 	Q_D(CartesianPlot);
 	if (enabled != d->yRangeBreakingEnabled)
 		exec(new CartesianPlotSetYRangeBreakingEnabledCmd(d, enabled, ki18n("%1: y-range breaking enabled")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeBreaks, CartesianPlot::RangeBreaks, yRangeBreaks, retransformScales)
 void CartesianPlot::setYRangeBreaks(const RangeBreaks& breaks) {
 	Q_D(CartesianPlot);
 	exec(new CartesianPlotSetYRangeBreaksCmd(d, breaks, ki18n("%1: y-range breaks changed")));
 }
 
 STD_SETTER_CMD_IMPL_S(CartesianPlot, SetTheme, QString, theme)
 void CartesianPlot::setTheme(const QString& theme) {
 	Q_D(CartesianPlot);
 	if (theme != d->theme) {
 		if (!theme.isEmpty()) {
 			beginMacro( i18n("%1: load theme %2", name(), theme) );
 			exec(new CartesianPlotSetThemeCmd(d, theme, ki18n("%1: set theme")));
 			loadTheme(theme);
 			endMacro();
 		} else
 			exec(new CartesianPlotSetThemeCmd(d, theme, ki18n("%1: disable theming")));
 	}
 }
 
 //################################################################
 //########################## Slots ###############################
 //################################################################
 void CartesianPlot::addHorizontalAxis() {
 	Axis* axis = new Axis("x-axis", Axis::AxisHorizontal);
 	if (axis->autoScale()) {
 		axis->setUndoAware(false);
 		axis->setStart(xMin());
 		axis->setEnd(xMax());
 		axis->setUndoAware(true);
 	}
 	addChild(axis);
 }
 
 void CartesianPlot::addVerticalAxis() {
 	Axis* axis = new Axis("y-axis", Axis::AxisVertical);
 	if (axis->autoScale()) {
 		axis->setUndoAware(false);
 		axis->setStart(yMin());
 		axis->setEnd(yMax());
 		axis->setUndoAware(true);
 	}
 	addChild(axis);
 }
 
 void CartesianPlot::addCurve() {
 	addChild(new XYCurve("xy-curve"));
 }
 
 void CartesianPlot::addEquationCurve() {
 	addChild(new XYEquationCurve("f(x)"));
 }
 
 void CartesianPlot::addHistogram() {
 	addChild(new Histogram("Histogram"));
 }
 
 /*!
  * returns the first selected XYCurve in the plot
  */
 const XYCurve* CartesianPlot::currentCurve() const {
-	for (const auto* curve: this->children<const XYCurve>()) {
+	for (const auto* curve : this->children<const XYCurve>()) {
 		if (curve->graphicsItem()->isSelected())
 			return curve;
 	}
 
 	return nullptr;
 }
 
 void CartesianPlot::addDataReductionCurve() {
 	XYDataReductionCurve* curve = new XYDataReductionCurve("Data reduction");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: reduce '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Reduction of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->dataReductionDataChanged(curve->dataReductionData());
 	} else {
 		beginMacro(i18n("%1: add data reduction curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addDifferentiationCurve() {
 	XYDifferentiationCurve* curve = new XYDifferentiationCurve("Differentiation");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: differentiate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Derivative of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->differentiationDataChanged(curve->differentiationData());
 	} else {
 		beginMacro(i18n("%1: add differentiation curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addIntegrationCurve() {
 	XYIntegrationCurve* curve = new XYIntegrationCurve("Integration");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: integrate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Integral of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->integrationDataChanged(curve->integrationData());
 	} else {
 		beginMacro(i18n("%1: add integration curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addInterpolationCurve() {
 	XYInterpolationCurve* curve = new XYInterpolationCurve("Interpolation");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: interpolate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Interpolation of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		curve->recalculate();
 		this->addChild(curve);
 		emit curve->interpolationDataChanged(curve->interpolationData());
 	} else {
 		beginMacro(i18n("%1: add interpolation curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addSmoothCurve() {
 	XYSmoothCurve* curve = new XYSmoothCurve("Smooth");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: smooth '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Smoothing of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->smoothDataChanged(curve->smoothData());
 	} else {
 		beginMacro(i18n("%1: add smoothing curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFitCurve() {
 	DEBUG("CartesianPlot::addFitCurve()");
 	XYFitCurve* curve = new XYFitCurve("fit");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: fit to '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Fit to '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 
 
 		//set the fit model category and type
 		const QAction* action = qobject_cast<const QAction*>(QObject::sender());
 		PlotDataDialog::AnalysisAction type = (PlotDataDialog::AnalysisAction)action->data().toInt();
 		curve->initFitData(type);
 		curve->initStartValues(curCurve);
 
 		//fit with weights for y if the curve has error bars for y
 		if (curCurve->yErrorType() == XYCurve::SymmetricError && curCurve->yErrorPlusColumn()) {
 			XYFitCurve::FitData fitData = curve->fitData();
 			fitData.yWeightsType = nsl_fit_weight_instrumental;
 			curve->setFitData(fitData);
 			curve->setYErrorColumn(curCurve->yErrorPlusColumn());
 		}
 
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->fitDataChanged(curve->fitData());
 	} else {
 		beginMacro(i18n("%1: add fit curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFourierFilterCurve() {
 	XYFourierFilterCurve* curve = new XYFourierFilterCurve("Fourier filter");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: Fourier filtering of '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Fourier filtering of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 	} else {
 		beginMacro(i18n("%1: add Fourier filter curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFourierTransformCurve() {
 	XYFourierTransformCurve* curve = new XYFourierTransformCurve("Fourier transform");
 	this->addChild(curve);
 }
 
 void CartesianPlot::addConvolutionCurve() {
 	XYConvolutionCurve* curve = new XYConvolutionCurve("Convolution");
 	this->addChild(curve);
 }
 
 void CartesianPlot::addCorrelationCurve() {
 	XYCorrelationCurve* curve = new XYCorrelationCurve("Correlation");
 	this->addChild(curve);
 }
 
 /*!
  * public helper function to set a legend object created outside of CartesianPlot, e.g. in \c OriginProjectParser.
  */
 void CartesianPlot::addLegend(CartesianPlotLegend* legend) {
 	m_legend = legend;
 	this->addChild(legend);
 }
 
 void CartesianPlot::addLegend() {
 	//don't do anything if there's already a legend
 	if (m_legend)
 		return;
 
 	m_legend = new CartesianPlotLegend(this, "legend");
 	this->addChild(m_legend);
 	m_legend->retransform();
 
 	//only one legend is allowed -> disable the action
 	if (m_menusInitialized)
 		addLegendAction->setEnabled(false);
 }
 
 void CartesianPlot::addTextLabel() {
 	TextLabel* label = new TextLabel("text label");
 	this->addChild(label);
 	label->setParentGraphicsItem(graphicsItem());
 }
 
 void CartesianPlot::addCustomPoint() {
 	CustomPoint* point = new CustomPoint(this, "custom point");
 	this->addChild(point);
 }
 
 void CartesianPlot::childAdded(const AbstractAspect* child) {
 	Q_D(CartesianPlot);
 	const XYCurve* curve = qobject_cast<const XYCurve*>(child);
 	if (curve) {
 		connect(curve, SIGNAL(dataChanged()), this, SLOT(dataChanged()));
 		connect(curve, SIGNAL(xDataChanged()), this, SLOT(xDataChanged()));
 		connect(curve, SIGNAL(yDataChanged()), this, SLOT(yDataChanged()));
 		connect(curve, SIGNAL(visibilityChanged(bool)), this, SLOT(curveVisibilityChanged()));
 
 		//update the legend on changes of the name, line and symbol styles
 		connect(curve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(lineTypeChanged(XYCurve::LineType)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(linePenChanged(QPen)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(lineOpacityChanged(qreal)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsStyleChanged(Symbol::Style)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsSizeChanged(qreal)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsRotationAngleChanged(qreal)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsOpacityChanged(qreal)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsBrushChanged(QBrush)), this, SLOT(updateLegend()));
 		connect(curve, SIGNAL(symbolsPenChanged(QPen)), this, SLOT(updateLegend()));
 
 		updateLegend();
 		d->curvesXMinMaxIsDirty = true;
 		d->curvesYMinMaxIsDirty = true;
 
 		//in case the first curve is added, check whether we start plotting datetime data
 		if (children<XYCurve>().size() == 1) {
 			const Column* col = dynamic_cast<const Column*>(curve->xColumn());
 			if (col) {
 				if (col->columnMode() == AbstractColumn::DateTime) {
 					setUndoAware(false);
 					setXRangeFormat(CartesianPlot::DateTime);
 					setUndoAware(true);
 
 					//set column's datetime format for all horizontal axis
 					for (auto* axis : children<Axis>()) {
 						if (axis->orientation() == Axis::AxisHorizontal) {
 							DateTime2StringFilter* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 							d->xRangeDateTimeFormat = filter->format();
 							axis->setUndoAware(false);
 							axis->setLabelsDateTimeFormat(d->xRangeDateTimeFormat);
 							axis->setUndoAware(true);
 						}
 					}
 				}
 			}
 
 			col = dynamic_cast<const Column*>(curve->yColumn());
 			if (col) {
 				if (col->columnMode() == AbstractColumn::DateTime) {
 					setUndoAware(false);
 					setYRangeFormat(CartesianPlot::DateTime);
 					setUndoAware(true);
 
 					//set column's datetime format for all vertical axis
 					for (auto* axis : children<Axis>()) {
 						if (axis->orientation() == Axis::AxisVertical) {
 							DateTime2StringFilter* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 							d->yRangeDateTimeFormat = filter->format();
 							axis->setUndoAware(false);
 							axis->setLabelsDateTimeFormat(d->yRangeDateTimeFormat);
 							axis->setUndoAware(true);
 						}
 					}
 				}
 			}
 		}
 	} else {
 		const Histogram* histo = qobject_cast<const Histogram*>(child);
 		if (histo) {
 			connect(histo, &Histogram::dataChanged, this, &CartesianPlot::dataChanged);
 			connect(histo, &Histogram::visibilityChanged, this, &CartesianPlot::curveVisibilityChanged);
 
 			updateLegend();
 		}
 	}
 
 	if (!isLoading()) {
 		//if a theme was selected, apply the theme settings for newly added children, too
 		if (!d->theme.isEmpty()) {
 			const WorksheetElement* el = dynamic_cast<const WorksheetElement*>(child);
 			if (el) {
 				KConfig config(ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig);
 				const_cast<WorksheetElement*>(el)->loadThemeConfig(config);
 			}
 		} else {
 			//no theme is available, apply the default colors for curves only, s.a. XYCurve::loadThemeConfig()
 			const XYCurve* curve = dynamic_cast<const XYCurve*>(child);
 			if (curve) {
 				int index = indexOfChild<XYCurve>(curve);
 				QColor themeColor;
 				if (index < m_themeColorPalette.size())
 					themeColor = m_themeColorPalette.at(index);
 				else {
 					if (m_themeColorPalette.size())
 						themeColor = m_themeColorPalette.last();
 				}
 
 				XYCurve* c = const_cast<XYCurve*>(curve);
 
 				//Line
 				QPen p = curve->linePen();
 				p.setColor(themeColor);
 				c->setLinePen(p);
 
 				//Drop line
 				p = curve->dropLinePen();
 				p.setColor(themeColor);
 				c->setDropLinePen(p);
 
 				//Symbol
 				QBrush brush = c->symbolsBrush();
 				brush.setColor(themeColor);
 				c->setSymbolsBrush(brush);
 				p = c->symbolsPen();
 				p.setColor(themeColor);
 				c->setSymbolsPen(p);
 
 				//Filling
 				c->setFillingFirstColor(themeColor);
 
 				//Error bars
 				p.setColor(themeColor);
 				c->setErrorBarsPen(p);
 			}
 		}
 	}
 }
 
 void CartesianPlot::childRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child) {
 	Q_UNUSED(parent);
 	Q_UNUSED(before);
 	if (m_legend == child) {
 		if (m_menusInitialized)
 			addLegendAction->setEnabled(true);
 		m_legend = nullptr;
 	} else {
 		const XYCurve* curve = qobject_cast<const XYCurve*>(child);
 		if (curve)
 			updateLegend();
 	}
 }
 
 void CartesianPlot::updateLegend() {
 	if (m_legend)
 		m_legend->retransform();
 }
 
 /*!
 	called when in one of the curves the data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::dataChanged() {
 	Q_D(CartesianPlot);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	if (d->autoScaleX && d->autoScaleY)
 		this->scaleAuto();
 	else if (d->autoScaleX)
 		this->scaleAutoX();
 	else if (d->autoScaleY)
 		this->scaleAutoY();
 	else {
 		//free ranges -> rentransform the curve that sent
 		XYCurve* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			Histogram* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->retransform();
 			else {
 				//no sender available, the function was called in CartesianPlot::dataChanged() (live data source got new data)
 				//-> retransform all available curves since we don't know which curves are affected.
 				//TODO: this logic can be very expensive
-				for (auto c : children<XYCurve>())
+				for (auto* c : children<XYCurve>())
 					c->retransform();
 			}
 		}
 	}
 }
 
 /*!
 	called when in one of the curves the x-data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::xDataChanged() {
 	if (project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesXMinMaxIsDirty = true;
 	if (d->autoScaleX)
 		this->scaleAutoX();
 	else {
 		XYCurve* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		curve->retransform();
 	}
 
 	//in case there is only one curve and its column mode was changed, check whether we start plotting datetime data
 	if (children<XYCurve>().size() == 1) {
 		XYCurve* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		const AbstractColumn* col = curve->xColumn();
 		if (col->columnMode() == AbstractColumn::DateTime && d->xRangeFormat != CartesianPlot::DateTime) {
 			setUndoAware(false);
 			setXRangeFormat(CartesianPlot::DateTime);
 			setUndoAware(true);
 		}
 	}
 }
 
 /*!
 	called when in one of the curves the x-data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::yDataChanged() {
 	if (project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesYMinMaxIsDirty = true;
 	if (d->autoScaleY)
 		this->scaleAutoY();
 	else {
 		XYCurve* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		curve->retransform();
 	}
 
 	//in case there is only one curve and its column mode was changed, check whether we start plotting datetime data
 	if (children<XYCurve>().size() == 1) {
 		XYCurve* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		const AbstractColumn* col = curve->yColumn();
 		if (col->columnMode() == AbstractColumn::DateTime && d->xRangeFormat != CartesianPlot::DateTime) {
 			setUndoAware(false);
 			setYRangeFormat(CartesianPlot::DateTime);
 			setUndoAware(true);
 		}
 	}
 }
 
 void CartesianPlot::curveVisibilityChanged() {
 	Q_D(CartesianPlot);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	updateLegend();
 	if (d->autoScaleX && d->autoScaleY)
 		this->scaleAuto();
 	else if (d->autoScaleX)
 		this->scaleAutoX();
 	else if (d->autoScaleY)
 		this->scaleAutoY();
 }
 
 void CartesianPlot::setMouseMode(const MouseMode mouseMode) {
 	Q_D(CartesianPlot);
 
 	d->mouseMode = mouseMode;
 	d->setHandlesChildEvents(mouseMode != CartesianPlot::SelectionMode);
 
 	QList<QGraphicsItem*> items = d->childItems();
 	if (d->mouseMode == CartesianPlot::SelectionMode) {
-		for (auto* item: items)
+		for (auto* item : items)
 			item->setFlag(QGraphicsItem::ItemStacksBehindParent, false);
 	} else {
-		for (auto* item: items)
+		for (auto* item : items)
 			item->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
 	}
 
 	//when doing zoom selection, prevent the graphics item from being movable
 	//if it's currently movable (no worksheet layout available)
 	const Worksheet* worksheet = dynamic_cast<const Worksheet*>(parentAspect());
 	if (worksheet) {
 		if (mouseMode == CartesianPlot::SelectionMode) {
 			if (worksheet->layout() != Worksheet::NoLayout)
 				graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 			else
 				graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, true);
 		} else   //zoom m_selection
 			graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 	}
 }
 
 void CartesianPlot::scaleAutoX() {
 	Q_D(CartesianPlot);
 	if (d->curvesXMinMaxIsDirty) {
 		int count = 0;
 		switch (d->rangeType) {
 		case CartesianPlot::RangeFree:
 			count = 0;
 			break;
 		case CartesianPlot::RangeLast:
 			count = -d->rangeLastValues;
 			break;
 		case CartesianPlot::RangeFirst:
 			count = d->rangeFirstValues;
 			break;
 		}
 
 		d->curvesXMin = INFINITY;
 		d->curvesXMax = -INFINITY;
 
 		//loop over all xy-curves and determine the maximum and minimum x-values
-		for (const auto* curve: this->children<const XYCurve>()) {
+		for (const auto* curve : this->children<const XYCurve>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->xColumn())
 				continue;
 
 			const double min = curve->xColumn()->minimum(count);
 			if (min < d->curvesXMin)
 				d->curvesXMin = min;
 
 			const double max = curve->xColumn()->maximum(count);
 			if (max > d->curvesXMax)
 				d->curvesXMax = max;
 		}
 
 		//loop over all histograms and determine the maximum and minimum x-values
-		for (const auto* curve: this->children<const Histogram>()) {
+		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->dataColumn())
 				continue;
 
 			const double min = curve->getXMinimum();
 			if (d->curvesXMin > min)
 				d->curvesXMin = min;
 
 			const double max = curve->getXMaximum();
 			if (max > d->curvesXMax)
 				d->curvesXMax = max;
 		}
 
 		d->curvesXMinMaxIsDirty = false;
 	}
 
 	bool update = false;
 	if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY) {
 		d->xMin = d->curvesXMin;
 		update = true;
 	}
 
 	if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY) {
 		d->xMax = d->curvesXMax;
 		update = true;
 	}
 
 	if (update) {
 		if (d->xMax == d->xMin) {
 			//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 			if (d->xMax != 0) {
 				d->xMax = d->xMax*1.1;
 				d->xMin = d->xMin*0.9;
 			} else {
 				d->xMax = 0.1;
 				d->xMin = -0.1;
 			}
 		} else {
 			double offset = (d->xMax - d->xMin)*d->autoScaleOffsetFactor;
 			d->xMin -= offset;
 			d->xMax += offset;
 		}
 		d->retransformScales();
 	}
 }
 
 void CartesianPlot::scaleAutoY() {
 	Q_D(CartesianPlot);
 
 	if (d->curvesYMinMaxIsDirty) {
 		int count = 0;
 		switch (d->rangeType) {
 		case CartesianPlot::RangeFree:
 			count = 0;
 			break;
 		case CartesianPlot::RangeLast:
 			count = -d->rangeLastValues;
 			break;
 		case CartesianPlot::RangeFirst:
 			count = d->rangeFirstValues;
 			break;
 		}
 
 		d->curvesYMin = INFINITY;
 		d->curvesYMax = -INFINITY;
 
 		//loop over all xy-curves and determine the maximum and minimum y-values
-		for (const auto* curve: this->children<const XYCurve>()) {
+		for (const auto* curve : this->children<const XYCurve>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->yColumn())
 				continue;
 
 			const double min = curve->yColumn()->minimum(count);
 			if (min < d->curvesYMin)
 				d->curvesYMin = min;
 
 			const double max = curve->yColumn()->maximum(count);
 			if (max > d->curvesYMax)
 				d->curvesYMax = max;
 		}
 
 		//loop over all histograms and determine the maximum y-value
-		for (const auto* curve: this->children<const Histogram>()) {
+		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 
 			const double min = curve->getYMinimum();
 			if (d->curvesYMin > min)
 				d->curvesYMin = min;
 
 			const double max = curve->getYMaximum();
 			if (max > d->curvesYMax)
 				d->curvesYMax = max;
 		}
 
 		d->curvesYMinMaxIsDirty = false;
 	}
 
 
 	bool update = false;
 	if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY) {
 		d->yMin = d->curvesYMin;
 		update = true;
 	}
 
 	if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY) {
 		d->yMax = d->curvesYMax;
 		update = true;
 	}
 	if (update) {
 		if (d->yMax == d->yMin) {
 			//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 			if (d->yMax != 0) {
 				d->yMax = d->yMax*1.1;
 				d->yMin = d->yMin*0.9;
 			} else {
 				d->yMax = 0.1;
 				d->yMin = -0.1;
 			}
 		} else {
 			double offset = (d->yMax - d->yMin)*d->autoScaleOffsetFactor;
 			d->yMin -= offset;
 			d->yMax += offset;
 		}
 		d->retransformScales();
 	}
 }
 
 void CartesianPlot::scaleAuto() {
 	DEBUG("CartesianPlot::scaleAuto()");
 	Q_D(CartesianPlot);
 
 	int count = 0;
 	switch (d->rangeType) {
 	case CartesianPlot::RangeFree:
 		count = 0;
 		break;
 	case CartesianPlot::RangeLast:
 		count = -d->rangeLastValues;
 		break;
 	case CartesianPlot::RangeFirst:
 		count = d->rangeFirstValues;
 		break;
 	}
 
 	if (d->curvesXMinMaxIsDirty) {
 		d->curvesXMin = INFINITY;
 		d->curvesXMax = -INFINITY;
 
 		//loop over all xy-curves and determine the maximum and minimum x-values
-		for (const auto* curve: this->children<const XYCurve>()) {
+		for (const auto* curve : this->children<const XYCurve>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->xColumn())
 				continue;
 
 			const double min = curve->xColumn()->minimum(count);
 			if (min < d->curvesXMin)
 				d->curvesXMin = min;
 
 			double max = curve->xColumn()->maximum(count);
 			if (max > d->curvesXMax)
 				d->curvesXMax = max;
 		}
 
 		//loop over all histograms and determine the maximum and minimum x-values
-		for (const auto* curve: this->children<const Histogram>()) {
+		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->dataColumn())
 				continue;
 
 			const double min = curve->getXMinimum();
 			if (d->curvesXMin > min)
 				d->curvesXMin = min;
 
 			const double max = curve->getXMaximum();
 			if (max > d->curvesXMax)
 				d->curvesXMax = max;
 
 		}
 
 		d->curvesXMinMaxIsDirty = false;
 	}
 
 	if (d->curvesYMinMaxIsDirty) {
 		d->curvesYMin = INFINITY;
 		d->curvesYMax = -INFINITY;
 
 		//loop over all xy-curves and determine the maximum and minimum y-values
-		for (const auto* curve: this->children<const XYCurve>()) {
+		for (const auto* curve : this->children<const XYCurve>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->yColumn())
 				continue;
 
 			const double min = curve->yColumn()->minimum(count);
 			if (min < d->curvesYMin)
 				d->curvesYMin = min;
 
 			const double max = curve->yColumn()->maximum(count);
 			if (max > d->curvesYMax)
 				d->curvesYMax = max;
 		}
 
 		//loop over all histograms and determine the maximum y-value
-		for (const auto* curve: this->children<const Histogram>()) {
+		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 
 			const double min = curve->getYMinimum();
 			if (d->curvesYMin > min)
 				d->curvesYMin = min;
 
 			const double max = curve->getYMaximum();
 			if (max > d->curvesYMax)
 				d->curvesYMax = max;
 		}
 	}
 
 	bool updateX = false;
 	bool updateY = false;
 	if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY) {
 		d->xMin = d->curvesXMin;
 		updateX = true;
 	}
 
 	if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY) {
 		d->xMax = d->curvesXMax;
 		updateX = true;
 	}
 
 	if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY) {
 		d->yMin = d->curvesYMin;
 		updateY = true;
 	}
 
 	if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY) {
 		d->yMax = d->curvesYMax;
 		updateY = true;
 	}
 	DEBUG(" xmin/xmax = " << d->xMin << '/' << d->xMax << ", ymin/ymax = " << d->yMin << '/' << d->yMax);
 
 	if (updateX || updateY) {
 		if (updateX) {
 			if (d->xMax == d->xMin) {
 				//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 				if (d->xMax != 0) {
 					d->xMax = d->xMax*1.1;
 					d->xMin = d->xMin*0.9;
 				} else {
 					d->xMax = 0.1;
 					d->xMin = -0.1;
 				}
 			} else {
 				double offset = (d->xMax - d->xMin)*d->autoScaleOffsetFactor;
 				d->xMin -= offset;
 				d->xMax += offset;
 			}
 		}
 		if (updateY) {
 			if (d->yMax == d->yMin) {
 				//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 				if (d->yMax != 0) {
 					d->yMax = d->yMax*1.1;
 					d->yMin = d->yMin*0.9;
 				} else {
 					d->yMax = 0.1;
 					d->yMin = -0.1;
 				}
 			} else {
 				double offset = (d->yMax - d->yMin)*d->autoScaleOffsetFactor;
 				d->yMin -= offset;
 				d->yMax += offset;
 			}
 		}
 		d->retransformScales();
 	}
 }
 
 void CartesianPlot::zoomIn() {
 	DEBUG("CartesianPlot::zoomIn()");
 	Q_D(CartesianPlot);
 
 	double oldRange = (d->xMax - d->xMin);
 	double newRange = (d->xMax - d->xMin) / m_zoomFactor;
 	d->xMax = d->xMax + (newRange - oldRange) / 2;
 	d->xMin = d->xMin - (newRange - oldRange) / 2;
 
 	oldRange = (d->yMax - d->yMin);
 	newRange = (d->yMax - d->yMin) / m_zoomFactor;
 	d->yMax = d->yMax + (newRange - oldRange) / 2;
 	d->yMin = d->yMin - (newRange - oldRange) / 2;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOut() {
 	Q_D(CartesianPlot);
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)*m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 
 	oldRange = (d->yMax-d->yMin);
 	newRange = (d->yMax-d->yMin)*m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomInX() {
 	Q_D(CartesianPlot);
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)/m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOutX() {
 	Q_D(CartesianPlot);
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)*m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomInY() {
 	Q_D(CartesianPlot);
 	double oldRange = (d->yMax-d->yMin);
 	double newRange = (d->yMax-d->yMin)/m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOutY() {
 	Q_D(CartesianPlot);
 	double oldRange = (d->yMax-d->yMin);
 	double newRange = (d->yMax-d->yMin)*m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftLeftX() {
 	Q_D(CartesianPlot);
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax -= offsetX;
 	d->xMin -= offsetX;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftRightX() {
 	Q_D(CartesianPlot);
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax += offsetX;
 	d->xMin += offsetX;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftUpY() {
 	Q_D(CartesianPlot);
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax += offsetY;
 	d->yMin += offsetY;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftDownY() {
 	Q_D(CartesianPlot);
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax -= offsetY;
 	d->yMin -= offsetY;
 	d->retransformScales();
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void CartesianPlot::visibilityChanged() {
 	Q_D(CartesianPlot);
 	this->setVisible(!d->isVisible());
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 CartesianPlotPrivate::CartesianPlotPrivate(CartesianPlot* plot) : AbstractPlotPrivate(plot),
 	curvesXMinMaxIsDirty(false), curvesYMinMaxIsDirty(false),
 	curvesXMin(INFINITY), curvesXMax(-INFINITY), curvesYMin(INFINITY), curvesYMax(-INFINITY),
 	q(plot),
 	mouseMode(CartesianPlot::SelectionMode),
 	cSystem(nullptr),
 	suppressRetransform(false),
 	panningStarted(false),
 	m_selectionBandIsShown(false) {
 
 	setData(0, WorksheetElement::NameCartesianPlot);
 }
 
 /*!
 	updates the position of plot rectangular in scene coordinates to \c r and recalculates the scales.
 	The size of the plot corresponds to the size of the plot area, the area which is filled with the background color etc.
 	and which can pose the parent item for several sub-items (like TextLabel).
 	Note, the size of the area used to define the coordinate system doesn't need to be equal to this plot area.
 	Also, the size (=bounding box) of CartesianPlot can be greater than the size of the plot area.
  */
 void CartesianPlotPrivate::retransform() {
 	if (suppressRetransform)
 		return;
 
 	PERFTRACE("CartesianPlotPrivate::retransform()");
 	prepareGeometryChange();
 	setPos( rect.x()+rect.width()/2, rect.y()+rect.height()/2);
 
 	updateDataRect();
 	retransformScales();
 
 	//plotArea position is always (0, 0) in parent's coordinates, don't need to update here
 	q->plotArea()->setRect(rect);
 
 	//call retransform() for the title and the legend (if available)
 	//when a predefined position relative to the (Left, Centered etc.) is used,
 	//the actual position needs to be updated on plot's geometry changes.
 	if (q->title())
 		q->title()->retransform();
 	if (q->m_legend)
 		q->m_legend->retransform();
 
 	WorksheetElementContainerPrivate::recalcShapeAndBoundingRect();
 }
 
 void CartesianPlotPrivate::retransformScales() {
 	PERFTRACE("CartesianPlotPrivate::retransformScales()");
 	DEBUG(" xmin/xmax = " << xMin << '/'<< xMax << ", ymin/ymax = " << yMin << '/' << yMax);
 
 	CartesianPlot* plot = dynamic_cast<CartesianPlot*>(q);
 	QVector<CartesianScale*> scales;
 
 	//perform the mapping from the scene coordinates to the plot's coordinates here.
 	QRectF itemRect = mapRectFromScene(rect);
 
 	//check ranges for log-scales
 	if (xScale != CartesianPlot::ScaleLinear)
 		checkXRange();
 
 	//check whether we have x-range breaks - the first break, if available, should be valid
 	bool hasValidBreak = (xRangeBreakingEnabled && !xRangeBreaks.list.isEmpty() && xRangeBreaks.list.first().isValid());
 
 	static const int breakGap = 20;
 	double sceneStart, sceneEnd, logicalStart, logicalEnd;
 
 	//create x-scales
 	int plotSceneStart = itemRect.x() + horizontalPadding;
 	int plotSceneEnd = itemRect.x() + itemRect.width() - horizontalPadding;
 	if (!hasValidBreak) {
 		//no breaks available -> range goes from the plot beginning to the end of the plot
 		sceneStart = plotSceneStart;
 		sceneEnd = plotSceneEnd;
 		logicalStart = xMin;
 		logicalEnd = xMax;
 
 		//TODO: how should we handle the case sceneStart == sceneEnd?
 		//(to reproduce, create plots and adjust the spacing/pading to get zero size for the plots)
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	} else {
 		int sceneEndLast = plotSceneStart;
 		int logicalEndLast = xMin;
-		for (const auto& rb: xRangeBreaks.list) {
+		for (const auto& rb : xRangeBreaks.list) {
 			if (!rb.isValid())
 				break;
 
 			//current range goes from the end of the previous one (or from the plot beginning) to curBreak.start
 			sceneStart = sceneEndLast;
 			if (&rb == &xRangeBreaks.list.first()) sceneStart += breakGap;
 			sceneEnd = plotSceneStart + (plotSceneEnd-plotSceneStart) * rb.position;
 			logicalStart = logicalEndLast;
 			logicalEnd = rb.start;
 
 			if (sceneStart != sceneEnd)
 				scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 
 			sceneEndLast = sceneEnd;
 			logicalEndLast = rb.end;
 		}
 
 		//add the remaining range going from the last available range break to the end of the plot (=end of the x-data range)
 		sceneStart = sceneEndLast+breakGap;
 		sceneEnd = plotSceneEnd;
 		logicalStart = logicalEndLast;
 		logicalEnd = xMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	}
 
 	cSystem->setXScales(scales);
 
 	//check ranges for log-scales
 	if (yScale != CartesianPlot::ScaleLinear)
 		checkYRange();
 
 	//check whether we have y-range breaks - the first break, if available, should be valid
 	hasValidBreak = (yRangeBreakingEnabled && !yRangeBreaks.list.isEmpty() && yRangeBreaks.list.first().isValid());
 
 	//create y-scales
 	scales.clear();
 	plotSceneStart = itemRect.y()+itemRect.height()-verticalPadding;
 	plotSceneEnd = itemRect.y()+verticalPadding;
 	if (!hasValidBreak) {
 		//no breaks available -> range goes from the plot beginning to the end of the plot
 		sceneStart = plotSceneStart;
 		sceneEnd = plotSceneEnd;
 		logicalStart = yMin;
 		logicalEnd = yMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	} else {
 		int sceneEndLast = plotSceneStart;
 		int logicalEndLast = yMin;
-		for (const auto& rb: yRangeBreaks.list) {
+		for (const auto& rb : yRangeBreaks.list) {
 			if (!rb.isValid())
 				break;
 
 			//current range goes from the end of the previous one (or from the plot beginning) to curBreak.start
 			sceneStart = sceneEndLast;
 			if (&rb == &yRangeBreaks.list.first()) sceneStart -= breakGap;
 			sceneEnd = plotSceneStart + (plotSceneEnd-plotSceneStart) * rb.position;
 			logicalStart = logicalEndLast;
 			logicalEnd = rb.start;
 
 			if (sceneStart != sceneEnd)
 				scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 
 			sceneEndLast = sceneEnd;
 			logicalEndLast = rb.end;
 		}
 
 		//add the remaining range going from the last available range break to the end of the plot (=end of the y-data range)
 		sceneStart = sceneEndLast-breakGap;
 		sceneEnd = plotSceneEnd;
 		logicalStart = logicalEndLast;
 		logicalEnd = yMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	}
 
 	cSystem->setYScales(scales);
 
 	//calculate the changes in x and y and save the current values for xMin, xMax, yMin, yMax
 	double deltaXMin = 0;
 	double deltaXMax = 0;
 	double deltaYMin = 0;
 	double deltaYMax = 0;
 
 	if (xMin != xMinPrev) {
 		deltaXMin = xMin - xMinPrev;
 		emit plot->xMinChanged(xMin);
 	}
 
 	if (xMax != xMaxPrev) {
 		deltaXMax = xMax - xMaxPrev;
 		emit plot->xMaxChanged(xMax);
 	}
 
 	if (yMin != yMinPrev) {
 		deltaYMin = yMin - yMinPrev;
 		emit plot->yMinChanged(yMin);
 	}
 
 	if (yMax!=yMaxPrev) {
 		deltaYMax = yMax - yMaxPrev;
 		emit plot->yMaxChanged(yMax);
 	}
 
 	xMinPrev = xMin;
 	xMaxPrev = xMax;
 	yMinPrev = yMin;
 	yMaxPrev = yMax;
 	//adjust auto-scale axes
-	for (auto* axis: q->children<Axis>()) {
+	for (auto* axis : q->children<Axis>()) {
 		if (!axis->autoScale())
 			continue;
 
 		if (axis->orientation() == Axis::AxisHorizontal) {
 			if (deltaXMax != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setEnd(xMax);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			if (deltaXMin != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setStart(xMin);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			//TODO;
 // 			if (axis->position() == Axis::AxisCustom && deltaYMin != 0) {
 // 				axis->setOffset(axis->offset() + deltaYMin, false);
 // 			}
 		} else {
 			if (deltaYMax != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setEnd(yMax);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			if (deltaYMin != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setStart(yMin);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 
 			//TODO;
 // 			if (axis->position() == Axis::AxisCustom && deltaXMin != 0) {
 // 				axis->setOffset(axis->offset() + deltaXMin, false);
 // 			}
 		}
 	}
 	// call retransform() on the parent to trigger the update of all axes and curvesю
 	//no need to do this on load since all plots are retransformed again after the project is loaded.
 	if (!q->isLoading())
 		q->retransform();
 }
 
 /*
  * calculates the rectangular of the are showing the actual data (plot's rect minus padding),
  * in plot's coordinates.
  */
 void CartesianPlotPrivate::updateDataRect() {
 	dataRect = mapRectFromScene(rect);
 	dataRect.setX(dataRect.x() + horizontalPadding);
 	dataRect.setY(dataRect.y() + verticalPadding);
 	dataRect.setWidth(dataRect.width() - horizontalPadding);
 	dataRect.setHeight(dataRect.height() - verticalPadding);
 }
 
 void CartesianPlotPrivate::rangeChanged() {
 	curvesXMinMaxIsDirty = true;
 	curvesYMinMaxIsDirty = true;
 	if (autoScaleX && autoScaleY)
 		q->scaleAuto();
 	else if (autoScaleX)
 		q->scaleAutoX();
 	else if (autoScaleY)
 		q->scaleAutoY();
 }
 
 void CartesianPlotPrivate::xRangeFormatChanged() {
 	for (auto* axis : q->children<Axis>()) {
 		if (axis->orientation() == Axis::AxisHorizontal)
 			axis->retransformTickLabelStrings();
 	}
 }
 
 void CartesianPlotPrivate::yRangeFormatChanged() {
 	for (auto* axis : q->children<Axis>()) {
 		if (axis->orientation() == Axis::AxisVertical)
 			axis->retransformTickLabelStrings();
 	}
 }
 
 /*!
  * don't allow any negative values for the x range when log or sqrt scalings are used
  */
 void CartesianPlotPrivate::checkXRange() {
 	double min = 0.01;
 
 	if (xMin <= 0.0) {
 		(min < xMax*min) ? xMin = min : xMin = xMax*min;
 		emit q->xMinChanged(xMin);
 	} else if (xMax <= 0.0) {
 		(-min > xMin*min) ? xMax = -min : xMax = xMin*min;
 		emit q->xMaxChanged(xMax);
 	}
 }
 
 /*!
  * don't allow any negative values for the y range when log or sqrt scalings are used
  */
 void CartesianPlotPrivate::checkYRange() {
 	double min = 0.01;
 
 	if (yMin <= 0.0) {
 		(min < yMax*min) ? yMin = min : yMin = yMax*min;
 		emit q->yMinChanged(yMin);
 	} else if (yMax <= 0.0) {
 		(-min > yMin*min) ? yMax = -min : yMax = yMin*min;
 		emit q->yMaxChanged(yMax);
 	}
 }
 
 CartesianScale* CartesianPlotPrivate::createScale(CartesianPlot::Scale type, double sceneStart, double sceneEnd, double logicalStart, double logicalEnd) {
 	DEBUG("CartesianPlotPrivate::createScale() scene start/end = " << sceneStart << '/' << sceneEnd << ", logical start/end = " << logicalStart << '/' << logicalEnd);
 // 	Interval<double> interval (logicalStart-0.01, logicalEnd+0.01); //TODO: move this to CartesianScale
 	Interval<double> interval (std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max());
 // 	Interval<double> interval (logicalStart, logicalEnd);
 	if (type == CartesianPlot::ScaleLinear)
 		return CartesianScale::createLinearScale(interval, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	else {
 		double base;
 		if (type == CartesianPlot::ScaleLog10)
 			base = 10.0;
 		else if (type == CartesianPlot::ScaleLog2)
 			base = 2.0;
 		else
 			base = M_E;
 
 		return CartesianScale::createLogScale(interval, sceneStart, sceneEnd, logicalStart, logicalEnd, base);
 	}
 }
 
 /*!
  * Reimplemented from QGraphicsItem.
  */
 QVariant CartesianPlotPrivate::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (change == QGraphicsItem::ItemPositionChange) {
 		const QPointF& itemPos = value.toPointF();//item's center point in parent's coordinates;
 		const qreal x = itemPos.x();
 		const qreal y = itemPos.y();
 
 		//calculate the new rect and forward the changes to the frontend
 		QRectF newRect;
 		const qreal w = rect.width();
 		const qreal h = rect.height();
 		newRect.setX(x-w/2);
 		newRect.setY(y-h/2);
 		newRect.setWidth(w);
 		newRect.setHeight(h);
 		emit q->rectChanged(newRect);
 	}
 	return QGraphicsItem::itemChange(change, value);
 }
 
 //##############################################################################
 //##################################  Events  ##################################
 //##############################################################################
 void CartesianPlotPrivate::mousePressEvent(QGraphicsSceneMouseEvent *event) {
 	if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode) {
 
 		if (mouseMode == CartesianPlot::ZoomSelectionMode)
 			m_selectionStart = event->pos();
 		else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 			m_selectionStart.setX(event->pos().x());
 			m_selectionStart.setY(dataRect.height()/2);
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 			m_selectionStart.setX(-dataRect.width()/2);
 			m_selectionStart.setY(event->pos().y());
 		}
 
 		m_selectionEnd = m_selectionStart;
 		m_selectionBandIsShown = true;
 	} else {
 		if ( dataRect.contains(event->pos()) ){
 			panningStarted = true;
 			m_panningStart = event->pos();
 			setCursor(Qt::ClosedHandCursor);
 		}
 		QGraphicsItem::mousePressEvent(event);
 	}
 }
 
 void CartesianPlotPrivate::mouseMoveEvent(QGraphicsSceneMouseEvent* event) {
 	if (mouseMode == CartesianPlot::SelectionMode) {
 		if (panningStarted && dataRect.contains(event->pos()) ) {
 			//don't retransform on small mouse movement deltas
 			const int deltaXScene = (m_panningStart.x() - event->pos().x());
 			const int deltaYScene = (m_panningStart.y() - event->pos().y());
 			if (abs(deltaXScene) < 5 && abs(deltaYScene) < 5)
 				return;
 
 			const QPointF logicalEnd = cSystem->mapSceneToLogical(event->pos());
 			const QPointF logicalStart = cSystem->mapSceneToLogical(m_panningStart);
 			const float deltaX = (logicalStart.x() - logicalEnd.x());
 			const float deltaY = (logicalStart.y() - logicalEnd.y());
 			xMax += deltaX;
 			xMin += deltaX;
 			yMax += deltaY;
 			yMin += deltaY;
 			retransformScales();
 			m_panningStart = event->pos();
 		} else
 			QGraphicsItem::mouseMoveEvent(event);
 	} else if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		QGraphicsItem::mouseMoveEvent(event);
 		if ( !boundingRect().contains(event->pos()) ) {
 			q->info("");
 			return;
 		}
 
 		QString info;
 		QPointF logicalStart = cSystem->mapSceneToLogical(m_selectionStart);
 		if (mouseMode == CartesianPlot::ZoomSelectionMode) {
 			m_selectionEnd = event->pos();
 			QPointF logicalEnd = cSystem->mapSceneToLogical(m_selectionEnd);
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info = QString::fromUtf8("Δx=") + QString::number(logicalEnd.x()-logicalStart.x());
 			else
 				info = i18n("from x=%1 to x=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.x()).toString(xRangeDateTimeFormat),
 													QDateTime::fromMSecsSinceEpoch(logicalEnd.x()).toString(xRangeDateTimeFormat));
 
 			info += QLatin1String(", ");
 			if (yRangeFormat == CartesianPlot::Numeric)
 				 info += QString::fromUtf8("Δy=") + QString::number(logicalEnd.y()-logicalStart.y());
 			else
 				info += i18n("from y=%1 to y=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.y()).toString(xRangeDateTimeFormat),
 													QDateTime::fromMSecsSinceEpoch(logicalEnd.y()).toString(xRangeDateTimeFormat));
 		} else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 			m_selectionEnd.setX(event->pos().x());
 			m_selectionEnd.setY(-dataRect.height()/2);
 			QPointF logicalEnd = cSystem->mapSceneToLogical(m_selectionEnd);
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info = QString::fromUtf8("Δx=") + QString::number(logicalEnd.x()-logicalStart.x());
 			else
 				info = i18n("from x=%1 to x=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.x()).toString(xRangeDateTimeFormat),
 													QDateTime::fromMSecsSinceEpoch(logicalEnd.x()).toString(xRangeDateTimeFormat));
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 			m_selectionEnd.setX(dataRect.width()/2);
 			m_selectionEnd.setY(event->pos().y());
 			QPointF logicalEnd = cSystem->mapSceneToLogical(m_selectionEnd);
 			if (yRangeFormat == CartesianPlot::Numeric)
 				 info = QString::fromUtf8("Δy=") + QString::number(logicalEnd.y()-logicalStart.y());
 			else
 				info = i18n("from y=%1 to y=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.y()).toString(xRangeDateTimeFormat),
 													QDateTime::fromMSecsSinceEpoch(logicalEnd.y()).toString(xRangeDateTimeFormat));
 		}
 		q->info(info);
 		update();
 	}
 }
 
 void CartesianPlotPrivate::mouseReleaseEvent(QGraphicsSceneMouseEvent* event) {
 	setCursor(Qt::ArrowCursor);
 	if (mouseMode == CartesianPlot::SelectionMode) {
 		panningStarted = false;
 
 		//TODO: why do we do this all the time?!?!
 		const QPointF& itemPos = pos();//item's center point in parent's coordinates;
 		const qreal x = itemPos.x();
 		const qreal y = itemPos.y();
 
 		//calculate the new rect and set it
 		QRectF newRect;
 		const qreal w = rect.width();
 		const qreal h = rect.height();
 		newRect.setX(x-w/2);
 		newRect.setY(y-h/2);
 		newRect.setWidth(w);
 		newRect.setHeight(h);
 
 		suppressRetransform = true;
 		q->setRect(newRect);
 		suppressRetransform = false;
 
 		QGraphicsItem::mouseReleaseEvent(event);
 	} else if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		//don't zoom if very small region was selected, avoid occasional/unwanted zooming
 		if ( qAbs(m_selectionEnd.x()-m_selectionStart.x()) < 20 || qAbs(m_selectionEnd.y()-m_selectionStart.y()) < 20 ) {
 			m_selectionBandIsShown = false;
 			return;
 		}
 
 		//determine the new plot ranges
 		QPointF logicalZoomStart = cSystem->mapSceneToLogical(m_selectionStart, AbstractCoordinateSystem::SuppressPageClipping);
 		QPointF logicalZoomEnd = cSystem->mapSceneToLogical(m_selectionEnd, AbstractCoordinateSystem::SuppressPageClipping);
 		if (m_selectionEnd.x() > m_selectionStart.x()) {
 			xMin = logicalZoomStart.x();
 			xMax = logicalZoomEnd.x();
 		} else {
 			xMin = logicalZoomEnd.x();
 			xMax = logicalZoomStart.x();
 		}
 
 		if (m_selectionEnd.y() > m_selectionStart.y()) {
 			yMin = logicalZoomEnd.y();
 			yMax = logicalZoomStart.y();
 		} else {
 			yMin = logicalZoomStart.y();
 			yMax = logicalZoomEnd.y();
 		}
 
 		m_selectionBandIsShown = false;
 		retransformScales();
 	}
 }
 
 void CartesianPlotPrivate::wheelEvent(QGraphicsSceneWheelEvent* event) {
 	//determine first, which axes are selected and zoom only in the corresponding direction.
 	//zoom the entire plot if no axes selected.
 	bool zoomX = false;
 	bool zoomY = false;
-	for (auto* axis: q->children<Axis>()) {
+	for (auto* axis : q->children<Axis>()) {
 		if (!axis->graphicsItem()->isSelected())
 			continue;
 
 		if (axis->orientation() == Axis::AxisHorizontal)
 			zoomX  = true;
 		else
 			zoomY = true;
 	}
 
 	if (event->delta() > 0) {
 		if (!zoomX && !zoomY) {
 			//no special axis selected -> zoom in everything
 			q->zoomIn();
 		} else {
 			if (zoomX) q->zoomInX();
 			if (zoomY) q->zoomInY();
 		}
 	} else {
 		if (!zoomX && !zoomY) {
 			//no special axis selected -> zoom in everything
 			q->zoomOut();
 		} else {
 			if (zoomX) q->zoomOutX();
 			if (zoomY) q->zoomOutY();
 		}
 	}
 }
 
 void CartesianPlotPrivate::hoverMoveEvent(QGraphicsSceneHoverEvent* event) {
 	QPointF point = event->pos();
 	QString info;
 	if (dataRect.contains(point)) {
 		QPointF logicalPoint = cSystem->mapSceneToLogical(point);
 		if (mouseMode == CartesianPlot::ZoomSelectionMode && !m_selectionBandIsShown) {
 			info = "x=";
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 
 			info += ", y=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.y());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.y()).toString(yRangeDateTimeFormat);
 		} else if (mouseMode == CartesianPlot::ZoomXSelectionMode && !m_selectionBandIsShown) {
 			QPointF p1(logicalPoint.x(), yMin);
 			QPointF p2(logicalPoint.x(), yMax);
 			m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1));
 			m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2));
 			info = "x=";
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 			update();
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode && !m_selectionBandIsShown) {
 			QPointF p1(xMin, logicalPoint.y());
 			QPointF p2(xMax, logicalPoint.y());
 			m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1));
 			m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2));
 			info = "y=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.y());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.y()).toString(yRangeDateTimeFormat);
 			update();
 		}
 	}
 	q->info(info);
 
 	QGraphicsItem::hoverMoveEvent(event);
 }
 
 void CartesianPlotPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget * widget) {
 	if (!isVisible())
 		return;
 
 	painter->setPen(QPen(Qt::black, 3));
 	if ((mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode)
 	        && (!m_selectionBandIsShown))
 		painter->drawLine(m_selectionStartLine);
 
 	if (m_selectionBandIsShown) {
 		painter->save();
 		painter->setPen(QPen(Qt::black, 5));
 		painter->drawRect(QRectF(m_selectionStart, m_selectionEnd));
 		painter->setBrush(Qt::blue);
 		painter->setOpacity(0.2);
 		painter->drawRect(QRectF(m_selectionStart, m_selectionEnd));
 		painter->restore();
 	}
 
 	WorksheetElementContainerPrivate::paint(painter, option, widget);
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 
 //! Save as XML
 void CartesianPlot::save(QXmlStreamWriter* writer) const {
 	Q_D(const CartesianPlot);
 
 	writer->writeStartElement( "cartesianPlot" );
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//applied theme
 	if (!d->theme.isEmpty()) {
 		writer->writeStartElement( "theme" );
 		writer->writeAttribute("name", d->theme);
 		writer->writeEndElement();
 	}
 
 	//geometry
 	writer->writeStartElement( "geometry" );
 	writer->writeAttribute( "x", QString::number(d->rect.x()) );
 	writer->writeAttribute( "y", QString::number(d->rect.y()) );
 	writer->writeAttribute( "width", QString::number(d->rect.width()) );
 	writer->writeAttribute( "height", QString::number(d->rect.height()) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//coordinate system and padding
 	writer->writeStartElement( "coordinateSystem" );
 	writer->writeAttribute( "autoScaleX", QString::number(d->autoScaleX) );
 	writer->writeAttribute( "autoScaleY", QString::number(d->autoScaleY) );
 	writer->writeAttribute( "xMin", QString::number(d->xMin) );
 	writer->writeAttribute( "xMax", QString::number(d->xMax) );
 	writer->writeAttribute( "yMin", QString::number(d->yMin) );
 	writer->writeAttribute( "yMax", QString::number(d->yMax) );
 	writer->writeAttribute( "xScale", QString::number(d->xScale) );
 	writer->writeAttribute( "yScale", QString::number(d->yScale) );
 	writer->writeAttribute( "xRangeFormat", QString::number(d->xRangeFormat) );
 	writer->writeAttribute( "yRangeFormat", QString::number(d->yRangeFormat) );
 	writer->writeAttribute( "horizontalPadding", QString::number(d->horizontalPadding) );
 	writer->writeAttribute( "verticalPadding", QString::number(d->verticalPadding) );
 	writer->writeEndElement();
 
 	//x-scale breaks
 	if (d->xRangeBreakingEnabled || !d->xRangeBreaks.list.isEmpty()) {
 		writer->writeStartElement("xRangeBreaks");
 		writer->writeAttribute( "enabled", QString::number(d->xRangeBreakingEnabled) );
-		for (const auto& rb: d->xRangeBreaks.list) {
+		for (const auto& rb : d->xRangeBreaks.list) {
 			writer->writeStartElement("xRangeBreak");
 			writer->writeAttribute("start", QString::number(rb.start));
 			writer->writeAttribute("end", QString::number(rb.end));
 			writer->writeAttribute("position", QString::number(rb.position));
 			writer->writeAttribute("style", QString::number(rb.style));
 			writer->writeEndElement();
 		}
 		writer->writeEndElement();
 	}
 
 	//y-scale breaks
 	if (d->yRangeBreakingEnabled || !d->yRangeBreaks.list.isEmpty()) {
 		writer->writeStartElement("yRangeBreaks");
 		writer->writeAttribute( "enabled", QString::number(d->yRangeBreakingEnabled) );
-		for (const auto& rb: d->yRangeBreaks.list) {
+		for (const auto& rb : d->yRangeBreaks.list) {
 			writer->writeStartElement("yRangeBreak");
 			writer->writeAttribute("start", QString::number(rb.start));
 			writer->writeAttribute("end", QString::number(rb.end));
 			writer->writeAttribute("position", QString::number(rb.position));
 			writer->writeAttribute("style", QString::number(rb.style));
 			writer->writeEndElement();
 		}
 		writer->writeEndElement();
 	}
 
 	//serialize all children (plot area, title text label, axes and curves)
-	for (auto *elem: children<WorksheetElement>(IncludeHidden))
+	for (auto* elem : children<WorksheetElement>(IncludeHidden))
 		elem->save(writer);
 
 	writer->writeEndElement(); // close "cartesianPlot" section
 }
 
 
 //! Load from XML
 bool CartesianPlot::load(XmlStreamReader* reader, bool preview) {
 	Q_D(CartesianPlot);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 	bool titleLabelRead = false;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "cartesianPlot")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader))
 				return false;
 		} else if (!preview && reader->name() == "theme") {
 			attribs = reader->attributes();
 			d->theme = attribs.value("name").toString();
 		} else if (!preview && reader->name() == "geometry") {
 			attribs = reader->attributes();
 
 			str = attribs.value("x").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("x").toString());
 			else
 				d->rect.setX( str.toDouble() );
 
 			str = attribs.value("y").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("y").toString());
 			else
 				d->rect.setY( str.toDouble() );
 
 			str = attribs.value("width").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("width").toString());
 			else
 				d->rect.setWidth( str.toDouble() );
 
 			str = attribs.value("height").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("height").toString());
 			else
 				d->rect.setHeight( str.toDouble() );
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (!preview && reader->name() == "coordinateSystem") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("autoScaleX", autoScaleX, bool);
 			READ_INT_VALUE("autoScaleY", autoScaleY, bool);
 
 			str = attribs.value("xMin").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("xMin").toString());
 			else {
 				d->xMin = str.toDouble();
 				d->xMinPrev = d->xMin;
 			}
 
 			str = attribs.value("xMax").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("xMax").toString());
 			else {
 				d->xMax = str.toDouble();
 				d->xMaxPrev = d->xMax;
 			}
 
 			str = attribs.value("yMin").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("yMin").toString());
 			else {
 				d->yMin = str.toDouble();
 				d->yMinPrev = d->yMin;
 			}
 
 			str = attribs.value("yMax").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("yMax").toString());
 			else {
 				d->yMax = str.toDouble();
 				d->yMaxPrev = d->yMax;
 			}
 
 			READ_INT_VALUE("xScale", xScale, CartesianPlot::Scale);
 			READ_INT_VALUE("yScale", yScale, CartesianPlot::Scale);
 
 			READ_INT_VALUE("xRangeFormat", xRangeFormat, CartesianPlot::RangeFormat);
 			READ_INT_VALUE("yRangeFormat", yRangeFormat, CartesianPlot::RangeFormat);
 
 			READ_DOUBLE_VALUE("horizontalPadding", horizontalPadding);
 			READ_DOUBLE_VALUE("verticalPadding", verticalPadding);
 		} else if (!preview && reader->name() == "xRangeBreaks") {
 			//delete default rang break
 			d->xRangeBreaks.list.clear();
 
 			attribs = reader->attributes();
 			READ_INT_VALUE("enabled", xRangeBreakingEnabled, bool);
 		} else if (!preview && reader->name() == "xRangeBreak") {
 			attribs = reader->attributes();
 
 			RangeBreak b;
 			str = attribs.value("start").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("start").toString());
 			else
 				b.start = str.toDouble();
 
 			str = attribs.value("end").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("end").toString());
 			else
 				b.end = str.toDouble();
 
 			str = attribs.value("position").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("position").toString());
 			else
 				b.position = str.toDouble();
 
 			str = attribs.value("style").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("style").toString());
 			else
 				b.style = CartesianPlot::RangeBreakStyle(str.toInt());
 
 			d->xRangeBreaks.list << b;
 		} else if (!preview && reader->name() == "yRangeBreaks") {
 			//delete default rang break
 			d->yRangeBreaks.list.clear();
 
 			attribs = reader->attributes();
 			READ_INT_VALUE("enabled", yRangeBreakingEnabled, bool);
 		} else if (!preview && reader->name() == "yRangeBreak") {
 			attribs = reader->attributes();
 
 			RangeBreak b;
 			str = attribs.value("start").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("start").toString());
 			else
 				b.start = str.toDouble();
 
 			str = attribs.value("end").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("end").toString());
 			else
 				b.end = str.toDouble();
 
 			str = attribs.value("position").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("position").toString());
 			else
 				b.position = str.toDouble();
 
 			str = attribs.value("style").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("style").toString());
 			else
 				b.style = CartesianPlot::RangeBreakStyle(str.toInt());
 
 			d->yRangeBreaks.list << b;
 		} else if (reader->name() == "textLabel") {
 			if (!titleLabelRead) {
 				//the first text label is always the title label
 				m_title->load(reader, preview);
 				titleLabelRead = true;
 			} else {
 				TextLabel* label = new TextLabel("text label");
 				if (label->load(reader, preview)) {
 					addChildFast(label);
 					label->setParentGraphicsItem(graphicsItem());
 				} else {
 					delete label;
 					return false;
 				}
 			}
 		} else if (reader->name() == "plotArea")
 			m_plotArea->load(reader, preview);
 		else if (reader->name() == "axis") {
 			Axis* axis = new Axis("");
 			if (axis->load(reader, preview))
 				addChildFast(axis);
 			else {
 				delete axis;
 				return false;
 			}
 		} else if (reader->name() == "xyCurve") {
 			XYCurve* curve = new XYCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyEquationCurve") {
 			XYEquationCurve* curve = new XYEquationCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDataReductionCurve") {
 			XYDataReductionCurve* curve = new XYDataReductionCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDifferentiationCurve") {
 			XYDifferentiationCurve* curve = new XYDifferentiationCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyIntegrationCurve") {
 			XYIntegrationCurve* curve = new XYIntegrationCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyInterpolationCurve") {
 			XYInterpolationCurve* curve = new XYInterpolationCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xySmoothCurve") {
 			XYSmoothCurve* curve = new XYSmoothCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFitCurve") {
 			XYFitCurve* curve = new XYFitCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierFilterCurve") {
 			XYFourierFilterCurve* curve = new XYFourierFilterCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierTransformCurve") {
 			XYFourierTransformCurve* curve = new XYFourierTransformCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyConvolutionCurve") {
 			XYConvolutionCurve* curve = new XYConvolutionCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyCorrelationCurve") {
 			XYCorrelationCurve* curve = new XYCorrelationCurve("");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "cartesianPlotLegend") {
 			m_legend = new CartesianPlotLegend(this, "");
 			if (m_legend->load(reader, preview))
 				addChildFast(m_legend);
 			else {
 				delete m_legend;
 				return false;
 			}
 		} else if (reader->name() == "customPoint") {
 			CustomPoint* point = new CustomPoint(this, "");
 			if (point->load(reader, preview))
 				addChildFast(point);
 			else {
 				delete point;
 				return false;
 			}
 		} else if(reader->name() == "Histogram") {
 			Histogram* curve = new Histogram("Histogram");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown cartesianPlot element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	if (preview)
 		return true;
 
 	d->retransform();
 
 	//if a theme was used, initialize the color palette
 	if (!d->theme.isEmpty()) {
 		//TODO: check whether the theme config really exists
 		KConfig config( ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig );
 		this->setColorPalette(config);
 	} else {
 		//initialize the color palette with default colors
 		this->setColorPalette(KConfig());
 	}
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void CartesianPlot::loadTheme(const QString& theme) {
 	KConfig config(ThemeHandler::themeFilePath(theme), KConfig::SimpleConfig);
 	loadThemeConfig(config);
 }
 
 void CartesianPlot::loadThemeConfig(const KConfig& config) {
 	QString str = config.name();
 	str = str.right(str.length() - str.lastIndexOf(QDir::separator()) - 1);
 	this->setTheme(str);
 
 	//load the color palettes for the curves
 	this->setColorPalette(config);
 
 	//load the theme for all the children
-	for (auto* child: children<WorksheetElement>(AbstractAspect::IncludeHidden))
+	for (auto* child : children<WorksheetElement>(AbstractAspect::IncludeHidden))
 		child->loadThemeConfig(config);
 
 	Q_D(CartesianPlot);
 	d->update(this->rect());
 }
 
 void CartesianPlot::saveTheme(KConfig &config) {
 	const QVector<Axis*>& axisElements = children<Axis>(AbstractAspect::IncludeHidden);
 	const QVector<PlotArea*>& plotAreaElements = children<PlotArea>(AbstractAspect::IncludeHidden);
 	const QVector<TextLabel*>& textLabelElements = children<TextLabel>(AbstractAspect::IncludeHidden);
 
 	axisElements.at(0)->saveThemeConfig(config);
 	plotAreaElements.at(0)->saveThemeConfig(config);
 	textLabelElements.at(0)->saveThemeConfig(config);
 
-	for (auto *child: children<XYCurve>(AbstractAspect::IncludeHidden))
+	for (auto *child : children<XYCurve>(AbstractAspect::IncludeHidden))
 		child->saveThemeConfig(config);
 }
 
 //Generating colors from 5-color theme palette
 void CartesianPlot::setColorPalette(const KConfig& config) {
 	if (config.hasGroup(QLatin1String("Theme"))) {
 		KConfigGroup group = config.group(QLatin1String("Theme"));
 
 		//read the five colors defining the palette
 		m_themeColorPalette.clear();
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor1", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor2", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor3", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor4", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor5", QColor()));
 	} else {
 		//no theme is available, provide 5 "default colors"
 		m_themeColorPalette.clear();
 		m_themeColorPalette.append(QColor(25, 25, 25));
 		m_themeColorPalette.append(QColor(0, 0, 127));
 		m_themeColorPalette.append(QColor(127 ,0, 0));
 		m_themeColorPalette.append(QColor(0, 127, 0));
 		m_themeColorPalette.append(QColor(85, 0, 127));
 	}
 
 	//generate 30 additional shades if the color palette contains more than one color
 	if (m_themeColorPalette.at(0) != m_themeColorPalette.at(1)) {
 		QColor c;
 
 		//3 factors to create shades from theme's palette
 		float fac[3] = {0.25f,0.45f,0.65f};
 
 		//Generate 15 lighter shades
 		for (int i = 0; i < 5; i++) {
 			for (int j = 1; j < 4; j++) {
 				c.setRed( m_themeColorPalette.at(i).red()*(1-fac[j-1]) );
 				c.setGreen( m_themeColorPalette.at(i).green()*(1-fac[j-1]) );
 				c.setBlue( m_themeColorPalette.at(i).blue()*(1-fac[j-1]) );
 				m_themeColorPalette.append(c);
 			}
 		}
 
 		//Generate 15 darker shades
 		for (int i = 0; i < 5; i++) {
 			for (int j = 4; j < 7; j++) {
 				c.setRed( m_themeColorPalette.at(i).red()+((255-m_themeColorPalette.at(i).red())*fac[j-4]) );
 				c.setGreen( m_themeColorPalette.at(i).green()+((255-m_themeColorPalette.at(i).green())*fac[j-4]) );
 				c.setBlue( m_themeColorPalette.at(i).blue()+((255-m_themeColorPalette.at(i).blue())*fac[j-4]) );
 				m_themeColorPalette.append(c);
 			}
 		}
 	}
 }
 
 const QList<QColor>& CartesianPlot::themeColorPalette() const {
 	return m_themeColorPalette;
 }
diff --git a/src/backend/worksheet/plots/cartesian/Histogram.cpp b/src/backend/worksheet/plots/cartesian/Histogram.cpp
index 7d9ca4f84..10e6256ea 100644
--- a/src/backend/worksheet/plots/cartesian/Histogram.cpp
+++ b/src/backend/worksheet/plots/cartesian/Histogram.cpp
@@ -1,1900 +1,1900 @@
 /***************************************************************************
 	File                 : Histogram.cpp
 	Project              : LabPlot
 	Description          : Histogram
 	--------------------------------------------------------------------
 	Copyright            : (C) 2016 Anu Mittal (anu22mittal@gmail.com)
 	Copyright            : (C) 2016-2018 by Alexander Semke (alexander.semke@web.de)
 	Copyright            : (C) 2017-2018 by Garvit Khatri (garvitdelhi@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                                           *
  *                                                                         *
  ***************************************************************************/
 
 /*!
   \class Histogram
   \brief A 2D-curve, provides an interface for editing many properties of the curve.
 
   \ingroup worksheet
   */
 #include "Histogram.h"
 #include "HistogramPrivate.h"
 #include "backend/core/column/Column.h"
 #include "backend/worksheet/plots/cartesian/CartesianCoordinateSystem.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "tools/ImageTools.h"
 #include "backend/lib/trace.h"
 
 #include <QPainter>
 #include <QGraphicsSceneContextMenuEvent>
 #include <QMenu>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 
 extern "C" {
 #include <gsl/gsl_histogram.h>
 #include <gsl/gsl_spline.h>
 #include <gsl/gsl_errno.h>
 }
 
 Histogram::Histogram(const QString &name)
 	: WorksheetElement(name), d_ptr(new HistogramPrivate(this)) {
 		init();
 }
 
 Histogram::Histogram(const QString &name, HistogramPrivate *dd)
 	: WorksheetElement(name), d_ptr(dd) {
 		init();
 }
 
 void Histogram::init() {
 	Q_D(Histogram);
 
 	KConfig config;
 	KConfigGroup group = config.group("Histogram");
 
 	d->dataColumn = nullptr;
 
 	d->type = (Histogram::HistogramType) group.readEntry("Type", (int)Histogram::Ordinary);
 	d->orientation = (Histogram::HistogramOrientation) group.readEntry("Orientation", (int)Histogram::Vertical);
 	d->binningMethod = (Histogram::BinningMethod) group.readEntry("BinningMethod", (int)Histogram::SquareRoot);
 	d->binCount = group.readEntry("BinCount", 10);
 	d->binWidth = group.readEntry("BinWidth", 1.0f);
 	d->autoBinRanges = group.readEntry("AutoBinRanges", true);
 
 	d->lineType = (Histogram::LineType) group.readEntry("LineType", (int)Histogram::Bars);
 	d->linePen.setStyle( (Qt::PenStyle) group.readEntry("LineStyle", (int)Qt::SolidLine) );
 	d->linePen.setColor( group.readEntry("LineColor", QColor(Qt::black)) );
 	d->linePen.setWidthF( group.readEntry("LineWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)) );
 	d->lineOpacity = group.readEntry("LineOpacity", 1.0);
 
 	d->symbolsStyle = (Symbol::Style)group.readEntry("SymbolStyle", (int)Symbol::NoSymbols);
 	d->symbolsSize = group.readEntry("SymbolSize", Worksheet::convertToSceneUnits(5, Worksheet::Point));
 	d->symbolsRotationAngle = group.readEntry("SymbolRotation", 0.0);
 	d->symbolsOpacity = group.readEntry("SymbolOpacity", 1.0);
 	d->symbolsBrush.setStyle( (Qt::BrushStyle)group.readEntry("SymbolFillingStyle", (int)Qt::SolidPattern) );
 	d->symbolsBrush.setColor( group.readEntry("SymbolFillingColor", QColor(Qt::black)) );
 	d->symbolsPen.setStyle( (Qt::PenStyle)group.readEntry("SymbolBorderStyle", (int)Qt::SolidLine) );
 	d->symbolsPen.setColor( group.readEntry("SymbolBorderColor", QColor(Qt::black)) );
 	d->symbolsPen.setWidthF( group.readEntry("SymbolBorderWidth", Worksheet::convertToSceneUnits(0.0, Worksheet::Point)) );
 
 	d->valuesType = (Histogram::ValuesType) group.readEntry("ValuesType", (int)Histogram::NoValues);
 	d->valuesColumn = nullptr;
 	d->valuesPosition = (Histogram::ValuesPosition) group.readEntry("ValuesPosition", (int)Histogram::ValuesAbove);
 	d->valuesDistance = group.readEntry("ValuesDistance", Worksheet::convertToSceneUnits(5, Worksheet::Point));
 	d->valuesRotationAngle = group.readEntry("ValuesRotation", 0.0);
 	d->valuesOpacity = group.readEntry("ValuesOpacity", 1.0);
 	d->valuesPrefix = group.readEntry("ValuesPrefix", "");
 	d->valuesSuffix = group.readEntry("ValuesSuffix", "");
 	d->valuesFont = group.readEntry("ValuesFont", QFont());
 	d->valuesFont.setPixelSize( Worksheet::convertToSceneUnits( 8, Worksheet::Point ) );
 	d->valuesColor = group.readEntry("ValuesColor", QColor(Qt::black));
 
 	d->fillingEnabled = group.readEntry("FillingEnabled", true);
 	d->fillingType = (PlotArea::BackgroundType) group.readEntry("FillingType", (int)PlotArea::Color);
 	d->fillingColorStyle = (PlotArea::BackgroundColorStyle) group.readEntry("FillingColorStyle", (int) PlotArea::SingleColor);
 	d->fillingImageStyle = (PlotArea::BackgroundImageStyle) group.readEntry("FillingImageStyle", (int) PlotArea::Scaled);
 	d->fillingBrushStyle = (Qt::BrushStyle) group.readEntry("FillingBrushStyle", (int) Qt::SolidPattern);
 	d->fillingFileName = group.readEntry("FillingFileName", QString());
 	d->fillingFirstColor = group.readEntry("FillingFirstColor", QColor(Qt::white));
 	d->fillingSecondColor = group.readEntry("FillingSecondColor", QColor(Qt::black));
 	d->fillingOpacity = group.readEntry("FillingOpacity", 1.0);
 
 	d->errorType = (Histogram::ErrorType) group.readEntry("ErrorType", (int)Histogram::NoError);
 	d->errorBarsType = (XYCurve::ErrorBarsType) group.readEntry("ErrorBarsType", (int)XYCurve::ErrorBarsSimple);
 	d->errorBarsCapSize = group.readEntry( "ErrorBarsCapSize", Worksheet::convertToSceneUnits(10, Worksheet::Point) );
 	d->errorBarsPen.setStyle( (Qt::PenStyle)group.readEntry("ErrorBarsStyle", (int)Qt::SolidLine) );
 	d->errorBarsPen.setColor( group.readEntry("ErrorBarsColor", QColor(Qt::black)) );
 	d->errorBarsPen.setWidthF( group.readEntry("ErrorBarsWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)) );
 	d->errorBarsOpacity = group.readEntry("ErrorBarsOpacity", 1.0);
 
 	this->initActions();
 }
 
 void Histogram::initActions() {
 	visibilityAction = new QAction(i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, &QAction::triggered, this, &Histogram::visibilityChangedSlot);
 }
 
 QMenu* Histogram::createContextMenu() {
 	QMenu *menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1); //skip the first action because of the "title-action"
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 	return menu;
 }
 
 /*!
   Returns an icon to be used in the project explorer.
   */
 QIcon Histogram::icon() const {
 	return QIcon::fromTheme("labplot-xy-curve");
 }
 
 QGraphicsItem* Histogram::graphicsItem() const {
 	return d_ptr;
 }
 
 STD_SWAP_METHOD_SETTER_CMD_IMPL(Histogram, SetVisible, bool, swapVisible)
 void Histogram::setVisible(bool on) {
 	Q_D(Histogram);
 	exec(new HistogramSetVisibleCmd(d, on, on ? ki18n("%1: set visible") : ki18n("%1: set invisible")));
 }
 
 bool Histogram::isVisible() const {
 	Q_D(const Histogram);
 	return d->isVisible();
 }
 
 void Histogram::setPrinting(bool on) {
 	Q_D(Histogram);
 	d->m_printing = on;
 }
 
 //##############################################################################
 //##########################  getter methods  ##################################
 //##############################################################################
 //general
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::HistogramType, type, type)
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::HistogramOrientation, orientation, orientation)
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::BinningMethod, binningMethod, binningMethod)
 BASIC_SHARED_D_READER_IMPL(Histogram, int, binCount, binCount)
 BASIC_SHARED_D_READER_IMPL(Histogram, float, binWidth, binWidth)
 BASIC_SHARED_D_READER_IMPL(Histogram, bool, autoBinRanges, autoBinRanges)
 BASIC_SHARED_D_READER_IMPL(Histogram, double, binRangesMin, binRangesMin)
 BASIC_SHARED_D_READER_IMPL(Histogram, double, binRangesMax, binRangesMax)
 BASIC_SHARED_D_READER_IMPL(Histogram, const AbstractColumn*, dataColumn, dataColumn)
 
 QString& Histogram::dataColumnPath() const {
 	return d_ptr->dataColumnPath;
 }
 
 //line
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::LineType, lineType, lineType)
 CLASS_SHARED_D_READER_IMPL(Histogram, QPen, linePen, linePen)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, lineOpacity, lineOpacity)
 
 //symbols
 BASIC_SHARED_D_READER_IMPL(Histogram, Symbol::Style, symbolsStyle, symbolsStyle)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, symbolsOpacity, symbolsOpacity)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, symbolsRotationAngle, symbolsRotationAngle)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, symbolsSize, symbolsSize)
 CLASS_SHARED_D_READER_IMPL(Histogram, QBrush, symbolsBrush, symbolsBrush)
 CLASS_SHARED_D_READER_IMPL(Histogram, QPen, symbolsPen, symbolsPen)
 
 //values
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::ValuesType, valuesType, valuesType)
 BASIC_SHARED_D_READER_IMPL(Histogram, const AbstractColumn *, valuesColumn, valuesColumn)
 QString& Histogram::valuesColumnPath() const {
 	return d_ptr->valuesColumnPath;
 }
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::ValuesPosition, valuesPosition, valuesPosition)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, valuesDistance, valuesDistance)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, valuesRotationAngle, valuesRotationAngle)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, valuesOpacity, valuesOpacity)
 CLASS_SHARED_D_READER_IMPL(Histogram, QString, valuesPrefix, valuesPrefix)
 CLASS_SHARED_D_READER_IMPL(Histogram, QString, valuesSuffix, valuesSuffix)
 CLASS_SHARED_D_READER_IMPL(Histogram, QColor, valuesColor, valuesColor)
 CLASS_SHARED_D_READER_IMPL(Histogram, QFont, valuesFont, valuesFont)
 
 //filling
 BASIC_SHARED_D_READER_IMPL(Histogram, bool, fillingEnabled, fillingEnabled)
 BASIC_SHARED_D_READER_IMPL(Histogram, PlotArea::BackgroundType, fillingType, fillingType)
 BASIC_SHARED_D_READER_IMPL(Histogram, PlotArea::BackgroundColorStyle, fillingColorStyle, fillingColorStyle)
 BASIC_SHARED_D_READER_IMPL(Histogram, PlotArea::BackgroundImageStyle, fillingImageStyle, fillingImageStyle)
 CLASS_SHARED_D_READER_IMPL(Histogram, Qt::BrushStyle, fillingBrushStyle, fillingBrushStyle)
 CLASS_SHARED_D_READER_IMPL(Histogram, QColor, fillingFirstColor, fillingFirstColor)
 CLASS_SHARED_D_READER_IMPL(Histogram, QColor, fillingSecondColor, fillingSecondColor)
 CLASS_SHARED_D_READER_IMPL(Histogram, QString, fillingFileName, fillingFileName)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, fillingOpacity, fillingOpacity)
 
 //error bars
 BASIC_SHARED_D_READER_IMPL(Histogram, Histogram::ErrorType, errorType, errorType)
 BASIC_SHARED_D_READER_IMPL(Histogram, XYCurve::ErrorBarsType, errorBarsType, errorBarsType)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, errorBarsCapSize, errorBarsCapSize)
 CLASS_SHARED_D_READER_IMPL(Histogram, QPen, errorBarsPen, errorBarsPen)
 BASIC_SHARED_D_READER_IMPL(Histogram, qreal, errorBarsOpacity, errorBarsOpacity)
 
 double Histogram::getYMaximum() const {
 	return d_ptr->getYMaximum();
 }
 
 double Histogram::getYMinimum() const {
 	return d_ptr->getYMinimum();
 }
 
 double Histogram::getXMaximum() const {
 	return d_ptr->getXMaximum();
 }
 
 double Histogram::getXMinimum() const {
 	return d_ptr->getXMinimum();
 }
 
 //##############################################################################
 //#################  setter methods and undo commands ##########################
 //##############################################################################
 
 //General
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetDataColumn, const AbstractColumn*, dataColumn, recalcHistogram)
 void Histogram::setDataColumn(const AbstractColumn* column) {
 	Q_D(Histogram);
 	if (column != d->dataColumn) {
 		exec(new HistogramSetDataColumnCmd(d, column, ki18n("%1: set data column")));
 
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Histogram::dataChanged);
 
 			//update the curve itself on changes
 			connect(column, &AbstractColumn::dataChanged, this, &Histogram::recalcHistogram);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Histogram::dataColumnAboutToBeRemoved);
 			//TODO: add disconnect in the undo-function
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetHistogramType, Histogram::HistogramType, type, updateType)
 void Histogram::setType(Histogram::HistogramType type) {
 	Q_D(Histogram);
 	if (type != d->type)
 		exec(new HistogramSetHistogramTypeCmd(d, type, ki18n("%1: set histogram type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetHistogramOrientation, Histogram::HistogramOrientation, orientation, updateOrientation)
 void Histogram::setOrientation(Histogram::HistogramOrientation orientation) {
     Q_D(Histogram);
 	if (orientation != d->orientation)
 		exec(new HistogramSetHistogramOrientationCmd(d, orientation, ki18n("%1: set histogram orientation")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetBinningMethod, Histogram::BinningMethod, binningMethod, recalcHistogram)
 void Histogram::setBinningMethod(Histogram::BinningMethod method) {
 	Q_D(Histogram);
 	if (method != d->binningMethod)
 		exec(new HistogramSetBinningMethodCmd(d, method, ki18n("%1: set binning method")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetBinCount, int, binCount, recalcHistogram)
 void Histogram::setBinCount(int count) {
 	Q_D(Histogram);
 	if (count != d->binCount)
 		exec(new HistogramSetBinCountCmd(d, count, ki18n("%1: set bin count")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetBinWidth, float, binWidth, recalcHistogram)
 void Histogram::setBinWidth(float width) {
 	Q_D(Histogram);
 	if (width != d->binWidth)
 		exec(new HistogramSetBinWidthCmd(d, width, ki18n("%1: set bin width")));
 }
 
 class HistogramSetAutoBinRangesCmd : public QUndoCommand {
 public:
 	HistogramSetAutoBinRangesCmd(HistogramPrivate* private_obj, bool autoBinRanges) :
 		m_private(private_obj), m_autoBinRanges(autoBinRanges), m_autoBinRangesOld(false), m_binRangesMinOld(0.0), m_binRangesMaxOld(0.0) {
 		setText(i18n("%1: change auto bin ranges", m_private->name()));
 	};
 
 	void redo() override {
 		m_autoBinRangesOld = m_private->autoBinRanges;
 		if (m_autoBinRanges) {
 			m_binRangesMinOld = m_private->binRangesMin;
 			m_binRangesMaxOld = m_private->binRangesMax;
 			m_private->q->recalcHistogram();
 		}
 		m_private->autoBinRanges = m_autoBinRanges;
 		emit m_private->q->autoBinRangesChanged(m_autoBinRanges);
 	};
 
 	void undo() override {
 		if (!m_autoBinRangesOld) {
 			m_private->binRangesMin = m_binRangesMinOld;
 			m_private->binRangesMax = m_binRangesMaxOld;
 			m_private->recalcHistogram();
 		}
 		m_private->autoBinRanges = m_autoBinRangesOld;
 		emit m_private->q->autoBinRangesChanged(m_autoBinRangesOld);
 	}
 
 private:
 	HistogramPrivate* m_private;
 	bool m_autoBinRanges;
 	bool m_autoBinRangesOld;
 	double m_binRangesMinOld;
 	double m_binRangesMaxOld;
 };
 
 void Histogram::setAutoBinRanges(bool autoBinRanges) {
 	Q_D(Histogram);
 	if (autoBinRanges != d->autoBinRanges)
 		exec(new HistogramSetAutoBinRangesCmd(d, autoBinRanges));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetBinRangesMin, double, binRangesMin, recalcHistogram)
 void Histogram::setBinRangesMin(double binRangesMin) {
 	Q_D(Histogram);
 	if (binRangesMin != d->binRangesMin)
 		exec(new HistogramSetBinRangesMinCmd(d, binRangesMin, ki18n("%1: set bin ranges start")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetBinRangesMax, double, binRangesMax, recalcHistogram)
 void Histogram::setBinRangesMax(double binRangesMax) {
 	Q_D(Histogram);
 	if (binRangesMax != d->binRangesMax)
 		exec(new HistogramSetBinRangesMaxCmd(d, binRangesMax, ki18n("%1: set bin ranges end")));
 }
 
 //Line
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetLineType, Histogram::LineType, lineType, updateLines)
 void Histogram::setLineType(LineType type) {
 	Q_D(Histogram);
 	if (type != d->lineType)
 		exec(new HistogramSetLineTypeCmd(d, type, ki18n("%1: line type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetLinePen, QPen, linePen, recalcShapeAndBoundingRect)
 void Histogram::setLinePen(const QPen &pen) {
 	Q_D(Histogram);
 	if (pen != d->linePen)
 		exec(new HistogramSetLinePenCmd(d, pen, ki18n("%1: set line style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetLineOpacity, qreal, lineOpacity, updatePixmap);
 void Histogram::setLineOpacity(qreal opacity) {
 	Q_D(Histogram);
 	if (opacity != d->lineOpacity)
 		exec(new HistogramSetLineOpacityCmd(d, opacity, ki18n("%1: set line opacity")));
 }
 
 // Symbols
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsStyle, Symbol::Style, symbolsStyle, updateSymbols)
 void Histogram::setSymbolsStyle(Symbol::Style style) {
 	Q_D(Histogram);
 	if (style != d->symbolsStyle)
 		exec(new HistogramSetSymbolsStyleCmd(d, style, ki18n("%1: set symbol style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsSize, qreal, symbolsSize, updateSymbols)
 void Histogram::setSymbolsSize(qreal size) {
 	Q_D(Histogram);
 	if (!qFuzzyCompare(1 + size, 1 + d->symbolsSize))
 		exec(new HistogramSetSymbolsSizeCmd(d, size, ki18n("%1: set symbol size")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsRotationAngle, qreal, symbolsRotationAngle, updateSymbols)
 void Histogram::setSymbolsRotationAngle(qreal angle) {
 	Q_D(Histogram);
 	if (!qFuzzyCompare(1 + angle, 1 + d->symbolsRotationAngle))
 		exec(new HistogramSetSymbolsRotationAngleCmd(d, angle, ki18n("%1: rotate symbols")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsBrush, QBrush, symbolsBrush, updatePixmap)
 void Histogram::setSymbolsBrush(const QBrush &brush) {
 	Q_D(Histogram);
 	if (brush != d->symbolsBrush)
 		exec(new HistogramSetSymbolsBrushCmd(d, brush, ki18n("%1: set symbol filling")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsPen, QPen, symbolsPen, updateSymbols)
 void Histogram::setSymbolsPen(const QPen &pen) {
 	Q_D(Histogram);
 	if (pen != d->symbolsPen)
 		exec(new HistogramSetSymbolsPenCmd(d, pen, ki18n("%1: set symbol outline style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetSymbolsOpacity, qreal, symbolsOpacity, updatePixmap)
 void Histogram::setSymbolsOpacity(qreal opacity) {
 	Q_D(Histogram);
 	if (opacity != d->symbolsOpacity)
 		exec(new HistogramSetSymbolsOpacityCmd(d, opacity, ki18n("%1: set symbols opacity")));
 }
 
 //Values
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesType, Histogram::ValuesType, valuesType, updateValues)
 void Histogram::setValuesType(Histogram::ValuesType type) {
 	Q_D(Histogram);
 	if (type != d->valuesType)
 		exec(new HistogramSetValuesTypeCmd(d, type, ki18n("%1: set values type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesColumn, const AbstractColumn*, valuesColumn, updateValues)
 void Histogram::setValuesColumn(const AbstractColumn* column) {
 	Q_D(Histogram);
 	if (column != d->valuesColumn) {
 		exec(new HistogramSetValuesColumnCmd(d, column, ki18n("%1: set values column")));
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Histogram::updateValues);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Histogram::valuesColumnAboutToBeRemoved);
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesPosition, Histogram::ValuesPosition, valuesPosition, updateValues)
 void Histogram::setValuesPosition(ValuesPosition position) {
 	Q_D(Histogram);
 	if (position != d->valuesPosition)
 		exec(new HistogramSetValuesPositionCmd(d, position, ki18n("%1: set values position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesDistance, qreal, valuesDistance, updateValues)
 void Histogram::setValuesDistance(qreal distance) {
 	Q_D(Histogram);
 	if (distance != d->valuesDistance)
 		exec(new HistogramSetValuesDistanceCmd(d, distance, ki18n("%1: set values distance")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesRotationAngle, qreal, valuesRotationAngle, updateValues)
 void Histogram::setValuesRotationAngle(qreal angle) {
 	Q_D(Histogram);
 	if (!qFuzzyCompare(1 + angle, 1 + d->valuesRotationAngle))
 		exec(new HistogramSetValuesRotationAngleCmd(d, angle, ki18n("%1: rotate values")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesOpacity, qreal, valuesOpacity, updatePixmap)
 void Histogram::setValuesOpacity(qreal opacity) {
 	Q_D(Histogram);
 	if (opacity != d->valuesOpacity)
 		exec(new HistogramSetValuesOpacityCmd(d, opacity, ki18n("%1: set values opacity")));
 }
 
 //TODO: Format, Precision
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesPrefix, QString, valuesPrefix, updateValues)
 void Histogram::setValuesPrefix(const QString& prefix) {
 	Q_D(Histogram);
 	if (prefix!= d->valuesPrefix)
 		exec(new HistogramSetValuesPrefixCmd(d, prefix, ki18n("%1: set values prefix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesSuffix, QString, valuesSuffix, updateValues)
 void Histogram::setValuesSuffix(const QString& suffix) {
 	Q_D(Histogram);
 	if (suffix!= d->valuesSuffix)
 		exec(new HistogramSetValuesSuffixCmd(d, suffix, ki18n("%1: set values suffix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesFont, QFont, valuesFont, updateValues)
 void Histogram::setValuesFont(const QFont& font) {
 	Q_D(Histogram);
 	if (font!= d->valuesFont)
 		exec(new HistogramSetValuesFontCmd(d, font, ki18n("%1: set values font")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetValuesColor, QColor, valuesColor, updatePixmap)
 void Histogram::setValuesColor(const QColor& color) {
 	Q_D(Histogram);
 	if (color != d->valuesColor)
 		exec(new HistogramSetValuesColorCmd(d, color, ki18n("%1: set values color")));
 }
 
 //Filling
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingEnabled, bool, fillingEnabled, updateFilling)
 void Histogram::setFillingEnabled(bool enabled) {
 	Q_D(Histogram);
 	if (enabled != d->fillingEnabled)
 		exec(new HistogramSetFillingEnabledCmd(d, enabled, ki18n("%1: filling changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingType, PlotArea::BackgroundType, fillingType, updatePixmap)
 void Histogram::setFillingType(PlotArea::BackgroundType type) {
 	Q_D(Histogram);
 	if (type != d->fillingType)
 		exec(new HistogramSetFillingTypeCmd(d, type, ki18n("%1: filling type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingColorStyle, PlotArea::BackgroundColorStyle, fillingColorStyle, updatePixmap)
 void Histogram::setFillingColorStyle(PlotArea::BackgroundColorStyle style) {
 	Q_D(Histogram);
 	if (style != d->fillingColorStyle)
 		exec(new HistogramSetFillingColorStyleCmd(d, style, ki18n("%1: filling color style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingImageStyle, PlotArea::BackgroundImageStyle, fillingImageStyle, updatePixmap)
 void Histogram::setFillingImageStyle(PlotArea::BackgroundImageStyle style) {
 	Q_D(Histogram);
 	if (style != d->fillingImageStyle)
 		exec(new HistogramSetFillingImageStyleCmd(d, style, ki18n("%1: filling image style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingBrushStyle, Qt::BrushStyle, fillingBrushStyle, updatePixmap)
 void Histogram::setFillingBrushStyle(Qt::BrushStyle style) {
 	Q_D(Histogram);
 	if (style != d->fillingBrushStyle)
 		exec(new HistogramSetFillingBrushStyleCmd(d, style, ki18n("%1: filling brush style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingFirstColor, QColor, fillingFirstColor, updatePixmap)
 void Histogram::setFillingFirstColor(const QColor& color) {
 	Q_D(Histogram);
 	if (color!= d->fillingFirstColor)
 		exec(new HistogramSetFillingFirstColorCmd(d, color, ki18n("%1: set filling first color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingSecondColor, QColor, fillingSecondColor, updatePixmap)
 void Histogram::setFillingSecondColor(const QColor& color) {
 	Q_D(Histogram);
 	if (color!= d->fillingSecondColor)
 		exec(new HistogramSetFillingSecondColorCmd(d, color, ki18n("%1: set filling second color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingFileName, QString, fillingFileName, updatePixmap)
 void Histogram::setFillingFileName(const QString& fileName) {
 	Q_D(Histogram);
 	if (fileName!= d->fillingFileName)
 		exec(new HistogramSetFillingFileNameCmd(d, fileName, ki18n("%1: set filling image")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetFillingOpacity, qreal, fillingOpacity, updatePixmap)
 void Histogram::setFillingOpacity(qreal opacity) {
 	Q_D(Histogram);
 	if (opacity != d->fillingOpacity)
 		exec(new HistogramSetFillingOpacityCmd(d, opacity, ki18n("%1: set filling opacity")));
 }
 
 //Error bars
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetErrorType, Histogram::ErrorType, errorType, updateErrorBars)
 void Histogram::setErrorType(ErrorType type) {
 	Q_D(Histogram);
 	if (type != d->errorType)
 		exec(new HistogramSetErrorTypeCmd(d, type, ki18n("%1: x-error type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetErrorBarsCapSize, qreal, errorBarsCapSize, updateErrorBars)
 void Histogram::setErrorBarsCapSize(qreal size) {
 	Q_D(Histogram);
 	if (size != d->errorBarsCapSize)
 		exec(new HistogramSetErrorBarsCapSizeCmd(d, size, ki18n("%1: set error bar cap size")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetErrorBarsType, XYCurve::ErrorBarsType, errorBarsType, updateErrorBars)
 void Histogram::setErrorBarsType(XYCurve::ErrorBarsType type) {
 	Q_D(Histogram);
 	if (type != d->errorBarsType)
 		exec(new HistogramSetErrorBarsTypeCmd(d, type, ki18n("%1: error bar type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetErrorBarsPen, QPen, errorBarsPen, recalcShapeAndBoundingRect)
 void Histogram::setErrorBarsPen(const QPen& pen) {
 	Q_D(Histogram);
 	if (pen != d->errorBarsPen)
 		exec(new HistogramSetErrorBarsPenCmd(d, pen, ki18n("%1: set error bar style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Histogram, SetErrorBarsOpacity, qreal, errorBarsOpacity, updatePixmap)
 void Histogram::setErrorBarsOpacity(qreal opacity) {
 	Q_D(Histogram);
 	if (opacity != d->errorBarsOpacity)
 		exec(new HistogramSetErrorBarsOpacityCmd(d, opacity, ki18n("%1: set error bar opacity")));
 }
 
 //##############################################################################
 //#################################  SLOTS  ####################################
 //##############################################################################
 void Histogram::retransform() {
 	d_ptr->retransform();
 }
 
 void Histogram::recalcHistogram() {
 	d_ptr->recalcHistogram();
 }
 
 //TODO
 void Histogram::handleResize(double horizontalRatio, double verticalRatio, bool pageResize) {
 	Q_UNUSED(pageResize);
 	Q_UNUSED(verticalRatio);
 	Q_D(const Histogram);
 
 	//setValuesDistance(d->distance*);
 	QFont font=d->valuesFont;
 	font.setPointSizeF(font.pointSizeF()*horizontalRatio);
 	setValuesFont(font);
 
 	retransform();
 }
 
 void Histogram::updateValues() {
 	d_ptr->updateValues();
 }
 
 void Histogram::dataColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Histogram);
 	if (aspect == d->dataColumn) {
 		d->dataColumn = nullptr;
 		d->retransform();
 	}
 }
 
 void Histogram::valuesColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Histogram);
 	if (aspect == d->valuesColumn) {
 		d->valuesColumn = nullptr;
 		d->updateValues();
 	}
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void Histogram::visibilityChangedSlot() {
 	Q_D(const Histogram);
 	this->setVisible(!d->isVisible());
 }
 
 //##############################################################################
 //######################### Private implementation #############################
 //##############################################################################
 HistogramPrivate::HistogramPrivate(Histogram *owner) :
 	m_printing(false),
 	m_hovered(false),
 	m_suppressRetransform(false),
 	m_suppressRecalc(false),
 	m_hoverEffectImageIsDirty(false),
 	m_selectionEffectImageIsDirty(false),
 	q(owner),
 	m_histogram(nullptr) {
 
 	setFlag(QGraphicsItem::ItemIsSelectable, true);
 	setAcceptHoverEvents(true);
 }
 
 QString HistogramPrivate::name() const {
 	return q->name();
 }
 
 QRectF HistogramPrivate::boundingRect() const {
 	return boundingRectangle;
 }
 
 double HistogramPrivate::getMaximumOccuranceofHistogram() {
 	if (m_histogram) {
 		double yMaxRange = -INFINITY;
 		switch(type) {
 			case Histogram::Ordinary: {
 				size_t maxYAddes = gsl_histogram_max_bin(m_histogram);
 				yMaxRange = gsl_histogram_get(m_histogram, maxYAddes);
 				break;
 			}
 			case Histogram::Cumulative: {
 				size_t maxYAddes = gsl_histogram_max_bin(m_histogram);
 				yMaxRange = gsl_histogram_get(m_histogram, maxYAddes);
 				double point =0.0;
 				for(size_t i=0; i < m_bins; ++i) {
 					point+= gsl_histogram_get(m_histogram,i);
 					if (point > yMaxRange) {
 						yMaxRange = point;
 					}
 				}
 				//yMaxRange = dataColumn->rowCount();
 				break;
 			}
 			case Histogram::AvgShift: {
 				//TODO
 			}
 		}
 		return yMaxRange;
 	}
 
 	return -INFINITY;
 }
 
 double HistogramPrivate::getXMinimum() {
 	switch(orientation) {
 		case Histogram::Vertical: {
 			return autoBinRanges ? dataColumn->minimum() : binRangesMin;
 		}
 		case Histogram::Horizontal: {
 			return 0;
 		}
 	}
 	return INFINITY;
 }
 
 double HistogramPrivate::getXMaximum() {
 	switch(orientation) {
 		case Histogram::Vertical: {
 			return autoBinRanges ? dataColumn->maximum() : binRangesMax;
 		}
 		case Histogram::Horizontal: {
 			return getMaximumOccuranceofHistogram();
 		}
 	}
 	return -INFINITY;
 }
 
 double HistogramPrivate::getYMinimum() {
 	switch(orientation) {
 		case Histogram::Vertical: {
 			return 0;
 		}
 		case Histogram::Horizontal: {
 			return autoBinRanges ? dataColumn->minimum() : binRangesMin;
 		}
 	}
 	return INFINITY;
 }
 
 double HistogramPrivate::getYMaximum() {
 	switch(orientation) {
 		case Histogram::Vertical: {
 			return getMaximumOccuranceofHistogram();
 		}
 		case Histogram::Horizontal: {
 			return autoBinRanges ? dataColumn->maximum() : binRangesMax;
 		}
 	}
 	return INFINITY;
 }
 
 /*!
   Returns the shape of the Histogram as a QPainterPath in local coordinates
   */
 QPainterPath HistogramPrivate::shape() const {
 	return curveShape;
 }
 
 void HistogramPrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	q->createContextMenu()->exec(event->screenPos());
 }
 
 bool HistogramPrivate::swapVisible(bool on) {
 	bool oldValue = isVisible();
 	setVisible(on);
 	emit q->visibilityChanged(on);
 	return oldValue;
 }
 
 /*!
   Triggers the update of lines, drop lines, symbols etc.
   */
 void HistogramPrivate::retransform() {
 	if (m_suppressRetransform)
 		return;
 
 	PERFTRACE(name().toLatin1() + ", HistogramPrivate::retransform()");
 
 	symbolPointsScene.clear();
 	symbolPointsLogical.clear();
 
 	if (!dataColumn) {
 		linePath = QPainterPath();
 		symbolsPath = QPainterPath();
 		valuesPath = QPainterPath();
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	m_suppressRecalc = true;
 	updateLines();
 	updateSymbols();
 	updateValues();
 	m_suppressRecalc = false;
 }
 
 void HistogramPrivate::recalcHistogram() {
 	PERFTRACE(name().toLatin1() + ", HistogramPrivate::recalcHistogram()");
 
 	if (m_histogram) {
 		gsl_histogram_free(m_histogram);
 		m_histogram = nullptr;
 	}
 
 	//calculate the number of valid data points
 	int count = 0;
 	for (int row = 0; row <dataColumn->rowCount(); ++row) {
 		if (dataColumn->isValid(row) && !dataColumn->isMasked(row))
 			++count;
 	}
 
 	//calculate the number of bins
 	if (count > 0) {
 		if (autoBinRanges) {
 			if (binRangesMin != dataColumn->minimum()) {
 				binRangesMin = dataColumn->minimum();
 				emit q->binRangesMinChanged(binRangesMin);
 			}
 
 			if (binRangesMax != dataColumn->maximum()) {
 				binRangesMax = dataColumn->maximum();
 				emit q->binRangesMaxChanged(binRangesMax);
 			}
 		} else {
 			if (binRangesMin >= binRangesMax) {
 				emit q->dataChanged();
 				return;
 			}
 
 		}
 
 		switch (binningMethod) {
 		case Histogram::ByNumber:
 			m_bins = (size_t)binCount;
 			break;
 		case Histogram::ByWidth:
 			m_bins = (size_t) (binRangesMax-binRangesMin)/binWidth;
 			break;
 		case Histogram::SquareRoot:
 			m_bins = (size_t)sqrt(count);
 			break;
 		case Histogram::Rice:
 			m_bins = (size_t)2*cbrt(count);
 			break;
 		case Histogram::Sturges:
 			m_bins = (size_t) 1 + log2(count);
 			break;
 		case Histogram::Doane: {
 			const double skewness = dynamic_cast<const Column*>(dataColumn)->statistics().skewness;
 			m_bins = (size_t)( 1 + log2(count) + log2(1 + abs(skewness)/sqrt((double)6*(count-2)/(count+1)/(count+3))) );
 			break;
 		}
 		case Histogram::Scott: {
 			const double sigma = dynamic_cast<const Column*>(dataColumn)->statistics().standardDeviation;
 			const double width = 3.5*sigma/cbrt(count);
 			DEBUG("blablub " << sigma << "  " << width << "  " <<(binRangesMax - binRangesMin)/width);
 			m_bins = (size_t)(binRangesMax - binRangesMin)/width;
 			break;
 		}
 		}
 
 		DEBUG("min " << binRangesMin);
 		DEBUG("max " << binRangesMax);
 		DEBUG("number of bins " << m_bins);
 
 		//calculate the histogram
 		if (m_bins > 0) {
 			m_histogram = gsl_histogram_alloc (m_bins);
 			gsl_histogram_set_ranges_uniform (m_histogram, binRangesMin, binRangesMax+1);
 
 			for (int row = 0; row < dataColumn->rowCount(); ++row) {
 				if ( dataColumn->isValid(row) && !dataColumn->isMasked(row) )
 					gsl_histogram_increment(m_histogram, dataColumn->valueAt(row));
 			}
 		} else
 			DEBUG("Number of bins must be positiv integer");
 	}
 
 	//histogram changed because of the actual data changes or because of new bin settings,
 	//emit dataChanged() in order to recalculate everything with the new size/shape of the histogram
 	emit q->dataChanged();
 }
 
 void HistogramPrivate::updateType() {
 	//type (ordinary or cumulative) changed,
 	//emit dataChanged() in order to recalculate everything with the new size/shape of the histogram
 	emit q->dataChanged();
 }
 
 void HistogramPrivate::updateOrientation() {
 	//orientation (horizontal or vertical) changed
 	//emit dataChanged() in order to recalculate everything with the new size/shape of the histogram
 	emit q->dataChanged();
 }
 
 /*!
   recalculates the painter path for the lines connecting the data points.
   Called each time when the type of this connection is changed.
   */
 void HistogramPrivate::updateLines() {
 	PERFTRACE(name().toLatin1() + ", HistogramPrivate::updateLines()");
 
 	linePath = QPainterPath();
 	lines.clear();
 	symbolPointsLogical.clear();
 
 	if (orientation == Histogram::Vertical)
 		verticalHistogram();
 	else
 		horizontalHistogram();
 
 	//map the lines and the symbol positions to the scene coordinates
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(q->parentAspect());
 	const CartesianCoordinateSystem* cSystem = dynamic_cast<const CartesianCoordinateSystem*>(plot->coordinateSystem());
 	Q_ASSERT(cSystem);
 	lines = cSystem->mapLogicalToScene(lines);
 	visiblePoints = std::vector<bool>(symbolPointsLogical.count(), false);
 	cSystem->mapLogicalToScene(symbolPointsLogical, symbolPointsScene, visiblePoints);
 
 	//new line path
-	for (const auto& line: lines) {
+	for (const auto& line : lines) {
 		linePath.moveTo(line.p1());
 		linePath.lineTo(line.p2());
 	}
 
 	updateFilling();
 	recalcShapeAndBoundingRect();
 }
 
 void HistogramPrivate::verticalHistogram() {
 	if (!m_histogram)
 		return;
 
 	const double min = gsl_histogram_min(m_histogram);
 	const double max = gsl_histogram_max(m_histogram);
 	const double width = (max - min)/m_bins;
 	double value = 0.;
 	if (lineType == Histogram::Bars) {
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram, i);
 			else
 				value += gsl_histogram_get(m_histogram, i);
 
 			const double x = min + i*width;
 			lines.append(QLineF(x, 0., x, value));
 			lines.append(QLineF(x, value, x + width, value));
 			lines.append(QLineF(x + width, value, x + width, 0.));
 			symbolPointsLogical.append(QPointF(x+width/2, value));
 		}
 	} else if (lineType == Histogram::NoLine || lineType == Histogram::Envelope) {
 		double prevValue = 0.;
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram, i);
 			else
 				value += gsl_histogram_get(m_histogram, i);
 
 			const double x = min + i*width;
 			lines.append(QLineF(x, prevValue, x, value));
 			lines.append(QLineF(x, value, x + width, value));
 			symbolPointsLogical.append(QPointF(x+width/2, value));
 
 			if (i== m_bins - 1)
 				lines.append(QLineF(x + width, value, x + width, 0.));
 
 			prevValue = value;
 		}
 	} else { //drop lines
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram, i);
 			else
 				value += gsl_histogram_get(m_histogram, i);
 
 			const double x = min + i*width - width/2;
 			lines.append(QLineF(x, 0., x, value));
 			symbolPointsLogical.append(QPointF(x, value));
 		}
 	}
 
 	lines.append(QLineF(min, 0., max, 0.));
 }
 
 void HistogramPrivate::horizontalHistogram() {
 	if (!m_histogram)
 		return;
 
 	const double min = gsl_histogram_min(m_histogram);
 	const double max = gsl_histogram_max(m_histogram);
 	const double width = (max - min)/m_bins;
 	double value = 0.;
 	if (lineType == Histogram::Bars) {
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram,i);
 			else
 				value += gsl_histogram_get(m_histogram,i);
 
 			const double y = min + i*width;
 			lines.append(QLineF(0., y, value, y));
 			lines.append(QLineF(value, y, value, y + width));
 			lines.append(QLineF(value, y + width, 0., y + width));
 			symbolPointsLogical.append(QPointF(value, y+width/2));
 		}
 	} else if (lineType == Histogram::NoLine || lineType == Histogram::Envelope) {
 		double prevValue = 0.;
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram, i);
 			else
 				value += gsl_histogram_get(m_histogram, i);
 
 			const double y = min + i*width;
 			lines.append(QLineF(prevValue, y, value, y));
 			lines.append(QLineF(value, y, value, y + width));
 			symbolPointsLogical.append(QPointF(value, y+width/2));
 
 			if (i== m_bins - 1)
 				lines.append(QLineF(value, y + width, 0., y + width));
 
 			prevValue = value;
 		}
 	} else { //drop lines
 		for(size_t i = 0; i < m_bins; ++i) {
 			if (type == Histogram::Ordinary)
 				value = gsl_histogram_get(m_histogram, i);
 			else
 				value += gsl_histogram_get(m_histogram, i);
 
 			const double y = min + i*width - width/2;
 			lines.append(QLineF(0., y, value, y));
 			symbolPointsLogical.append(QPointF(value, y));
 		}
 	}
 
 	lines.append(QLineF(0., min, 0., max));
 }
 
 void HistogramPrivate::updateSymbols() {
 	symbolsPath = QPainterPath();
 	if (symbolsStyle != Symbol::NoSymbols) {
 		QPainterPath path = Symbol::pathFromStyle(symbolsStyle);
 
 		QTransform trafo;
 		trafo.scale(symbolsSize, symbolsSize);
 		path = trafo.map(path);
 		trafo.reset();
 
 		if (symbolsRotationAngle != 0) {
 			trafo.rotate(symbolsRotationAngle);
 			path = trafo.map(path);
 		}
 
 		for (const auto& point : symbolPointsScene) {
 			trafo.reset();
 			trafo.translate(point.x(), point.y());
 			symbolsPath.addPath(trafo.map(path));
 		}
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 /*!
   recreates the value strings to be shown and recalculates their draw position.
   */
 void HistogramPrivate::updateValues() {
 	valuesPath = QPainterPath();
 	valuesPoints.clear();
 	valuesStrings.clear();
 
 	if (valuesType == Histogram::NoValues || !m_histogram) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//determine the value string for all points that are currently visible in the plot
 	if (valuesType == Histogram::ValuesBinEntries) {
 		switch(type) {
 		case Histogram::Ordinary:
 			for(size_t i=0; i<m_bins; ++i) {
 				if (!visiblePoints[i]) continue;
 				valuesStrings << valuesPrefix + QString::number(gsl_histogram_get(m_histogram, i)) + valuesSuffix;
 			}
 			break;
 		case Histogram::Cumulative: {
 			value = 0;
 			for(size_t i=0; i<m_bins; ++i) {
 				if (!visiblePoints[i]) continue;
 				value += gsl_histogram_get(m_histogram, i);
 				valuesStrings << valuesPrefix + QString::number(value) + valuesSuffix;
 			}
 			break;
 		}
 		case Histogram::AvgShift:
 			break;
 		}
 	} else if (valuesType == Histogram::ValuesCustomColumn) {
 		if (!valuesColumn) {
 			recalcShapeAndBoundingRect();
 			return;
 		}
 
 		const int endRow = qMin(symbolPointsLogical.size(), valuesColumn->rowCount());
 		const AbstractColumn::ColumnMode xColMode = valuesColumn->columnMode();
 		for (int i = 0; i < endRow; ++i) {
 			if (!visiblePoints[i]) continue;
 
 			if ( !valuesColumn->isValid(i) || valuesColumn->isMasked(i) )
 				continue;
 
 			switch (xColMode) {
 				case AbstractColumn::Numeric:
 					valuesStrings << valuesPrefix + QString::number(valuesColumn->valueAt(i)) + valuesSuffix;
 					break;
 				case AbstractColumn::Text:
 					valuesStrings << valuesPrefix + valuesColumn->textAt(i) + valuesSuffix;
 				case AbstractColumn::Integer:
 				case AbstractColumn::DateTime:
 				case AbstractColumn::Month:
 				case AbstractColumn::Day:
 					//TODO
 					break;
 			}
 		}
 	}
 
 	//Calculate the coordinates where to paint the value strings.
 	//The coordinates depend on the actual size of the string.
 	QPointF tempPoint;
 	QFontMetrics fm(valuesFont);
 	qreal w;
 	const qreal h = fm.ascent();
 	switch(valuesPosition) {
 		case Histogram::ValuesAbove:
 			for (int i = 0; i < valuesStrings.size(); i++) {
 				w = fm.width(valuesStrings.at(i));
 				tempPoint.setX( symbolPointsScene.at(i).x() -w/2);
 				tempPoint.setY( symbolPointsScene.at(i).y() - valuesDistance );
 				valuesPoints.append(tempPoint);
 			}
 			break;
 		case Histogram::ValuesUnder:
 			for (int i = 0; i < valuesStrings.size(); i++) {
 				w = fm.width(valuesStrings.at(i));
 				tempPoint.setX( symbolPointsScene.at(i).x() -w/2);
 				tempPoint.setY( symbolPointsScene.at(i).y() + valuesDistance + h/2);
 				valuesPoints.append(tempPoint);
 			}
 			break;
 		case Histogram::ValuesLeft:
 			for (int i = 0; i < valuesStrings.size(); i++) {
 				w = fm.width(valuesStrings.at(i));
 				tempPoint.setX( symbolPointsScene.at(i).x() - valuesDistance - w - 1);
 				tempPoint.setY( symbolPointsScene.at(i).y());
 				valuesPoints.append(tempPoint);
 			}
 			break;
 		case Histogram::ValuesRight:
 			for (int i = 0; i < valuesStrings.size(); i++) {
 				tempPoint.setX( symbolPointsScene.at(i).x() + valuesDistance - 1);
 				tempPoint.setY( symbolPointsScene.at(i).y() );
 				valuesPoints.append(tempPoint);
 			}
 			break;
 	}
 
 	QTransform trafo;
 	QPainterPath path;
 	for (int i = 0; i < valuesPoints.size(); i++) {
 		path = QPainterPath();
 		path.addText( QPoint(0,0), valuesFont, valuesStrings.at(i) );
 
 		trafo.reset();
 		trafo.translate( valuesPoints.at(i).x(), valuesPoints.at(i).y() );
 		if (valuesRotationAngle!=0)
 			trafo.rotate( -valuesRotationAngle );
 
 		valuesPath.addPath(trafo.map(path));
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void HistogramPrivate::updateFilling() {
 	fillPolygons.clear();
 
 	if (!fillingEnabled || lineType == Histogram::DropLines) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	QVector<QLineF> fillLines;
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(q->parentAspect());
 	const AbstractCoordinateSystem* cSystem = plot->coordinateSystem();
 
 	//if there're no interpolation lines available (Histogram::NoLine selected), create line-interpolation,
 	//use already available lines otherwise.
 	if (lines.size())
 		fillLines = lines;
 	else {
 		for (int i=0; i<symbolPointsLogical.count()-1; i++)
 			fillLines.append(QLineF(symbolPointsLogical.at(i), symbolPointsLogical.at(i+1)));
 		fillLines = cSystem->mapLogicalToScene(fillLines);
 	}
 
 	//no lines available (no points), nothing to do
 	if (!fillLines.size())
 		return;
 
 
 	//create polygon(s):
 	//1. Depending on the current zoom-level, only a subset of the curve may be visible in the plot
 	//and more of the filling area should be shown than the area defined by the start and end points of the currently visible points.
 	//We check first whether the curve crosses the boundaries of the plot and determine new start and end points and put them to the boundaries.
 	//2. Furthermore, depending on the current filling type we determine the end point (x- or y-coordinate) where all polygons are closed at the end.
 	QPolygonF pol;
 	QPointF start = fillLines.at(0).p1(); //starting point of the current polygon, initialize with the first visible point
 	QPointF end = fillLines.at(fillLines.size()-1).p2(); //starting point of the current polygon, initialize with the last visible point
 	const QPointF& first = symbolPointsLogical.at(0); //first point of the curve, may not be visible currently
 	const QPointF& last = symbolPointsLogical.at(symbolPointsLogical.size()-1);//first point of the curve, may not be visible currently
 	QPointF edge;
 	float yEnd=0;
 
 	//fillingPosition == Histogram::FillingZeroBaseline)
 	edge = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax()));
 
 	//start point
 	if (AbstractCoordinateSystem::essentiallyEqual(start.y(), edge.y())) {
 		if (plot->yMax()>0) {
 			if (first.x() < plot->xMin())
 				start = edge;
 			else if (first.x() > plot->xMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMax()));
 		} else {
 			if (first.x() < plot->xMin())
 				start = edge;
 			else if (first.x() > plot->xMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMin()));
 		}
 	}
 
 	//end point
 	if (AbstractCoordinateSystem::essentiallyEqual(end.y(), edge.y())) {
 		if (plot->yMax()>0) {
 			if (last.x() < plot->xMin())
 				end = edge;
 			else if (last.x() > plot->xMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMax()));
 		} else {
 			if (last.x() < plot->xMin())
 				end = edge;
 			else if (last.x() > plot->xMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMin()));
 		}
 	}
 
 	yEnd = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin()>0 ? plot->yMin() : 0)).y();
 
 	if (start != fillLines.at(0).p1())
 		pol << start;
 
 	QPointF p1, p2;
 	for (int i=0; i<fillLines.size(); ++i) {
 		const QLineF& line = fillLines.at(i);
 		p1 = line.p1();
 		p2 = line.p2();
 		if (i!=0 && p1!=fillLines.at(i-1).p2())
 			pol << fillLines.at(i-1).p2() << p1;
 
 		pol << p1 << p2;
 	}
 
 	if (p2!=end)
 		pol << end;
 
 	//close the last polygon
 	pol << QPointF(end.x(), yEnd);
 	pol << QPointF(start.x(), yEnd);
 
 	fillPolygons << pol;
 	recalcShapeAndBoundingRect();
 }
 
 void HistogramPrivate::updateErrorBars() {
 
 }
 
 /*!
   recalculates the outer bounds and the shape of the curve.
   */
 void HistogramPrivate::recalcShapeAndBoundingRect() {
 	//if (m_suppressRecalc)
 	//	return;
 
 	prepareGeometryChange();
 	curveShape = QPainterPath();
 	if (lineType != Histogram::NoLine)
 		curveShape.addPath(WorksheetElement::shapeFromPath(linePath, linePen));
 
 	if (symbolsStyle != Symbol::NoSymbols)
 		curveShape.addPath(symbolsPath);
 
 	if (valuesType != Histogram::NoValues)
 		curveShape.addPath(valuesPath);
 
 	boundingRectangle = curveShape.boundingRect();
 
 	for (const auto& pol : fillPolygons)
 		boundingRectangle = boundingRectangle.united(pol.boundingRect());
 
 	//TODO: when the selection is painted, line intersections are visible.
 	//simplified() removes those artifacts but is horrible slow for curves with large number of points.
 	//search for an alternative.
 	//curveShape = curveShape.simplified();
 
 	updatePixmap();
 }
 
 void HistogramPrivate::draw(QPainter* painter) {
 	PERFTRACE(name().toLatin1() + ", HistogramPrivate::draw()");
 
 	//drawing line
 	if (lineType != Histogram::NoLine) {
 		painter->setOpacity(lineOpacity);
 		painter->setPen(linePen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(linePath);
 	}
 
 	//draw filling
 	if (fillingEnabled) {
 		painter->setOpacity(fillingOpacity);
 		painter->setPen(Qt::SolidLine);
 		drawFilling(painter);
 	}
 
 	//draw symbols
 	if (symbolsStyle != Symbol::NoSymbols) {
 		painter->setOpacity(symbolsOpacity);
 		painter->setPen(symbolsPen);
 		painter->setBrush(symbolsBrush);
 		drawSymbols(painter);
 	}
 
 	//draw values
 	if (valuesType != Histogram::NoValues) {
 		painter->setOpacity(valuesOpacity);
 		painter->setPen(valuesColor);
 		painter->setBrush(Qt::SolidPattern);
 		drawValues(painter);
 	}
 }
 
 void HistogramPrivate::updatePixmap() {
 	QPixmap pixmap(boundingRectangle.width(), boundingRectangle.height());
 	if (boundingRectangle.width()==0 || boundingRectangle.width()==0) {
 		m_pixmap = pixmap;
 		m_hoverEffectImageIsDirty = true;
 		m_selectionEffectImageIsDirty = true;
 		return;
 	}
 	pixmap.fill(Qt::transparent);
 	QPainter painter(&pixmap);
 	painter.setRenderHint(QPainter::Antialiasing, true);
 	painter.translate(-boundingRectangle.topLeft());
 
 	draw(&painter);
 	painter.end();
 
 	m_pixmap = pixmap;
 	m_hoverEffectImageIsDirty = true;
 	m_selectionEffectImageIsDirty = true;
 }
 
 /*!
   Reimplementation of QGraphicsItem::paint(). This function does the actual painting of the curve.
   \sa QGraphicsItem::paint().
   */
 void HistogramPrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option);
 	Q_UNUSED(widget);
 	if (!isVisible())
 		return;
 
 	painter->setPen(Qt::NoPen);
 	painter->setBrush(Qt::NoBrush);
 	painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
 	if ( KSharedConfig::openConfig()->group("Settings_Worksheet").readEntry<bool>("DoubleBuffering", true) )
 		painter->drawPixmap(boundingRectangle.topLeft(), m_pixmap); //draw the cached pixmap (fast)
 	else
 		draw(painter); //draw directly again (slow)
 
 	if (m_hovered && !isSelected() && !m_printing) {
 		if (m_hoverEffectImageIsDirty) {
 			QPixmap pix = m_pixmap;
 			pix.fill(QApplication::palette().color(QPalette::Shadow));
 			pix.setAlphaChannel(m_pixmap.alphaChannel());
 			m_hoverEffectImage = ImageTools::blurred(pix.toImage(), m_pixmap.rect(), 5);
 			m_hoverEffectImageIsDirty = false;
 		}
 
 		painter->drawImage(boundingRectangle.topLeft(), m_hoverEffectImage, m_pixmap.rect());
 		return;
 	}
 
 	if (isSelected() && !m_printing) {
 		if (m_selectionEffectImageIsDirty) {
 			QPixmap pix = m_pixmap;
 			pix.fill(QApplication::palette().color(QPalette::Highlight));
 			pix.setAlphaChannel(m_pixmap.alphaChannel());
 			m_selectionEffectImage = ImageTools::blurred(pix.toImage(), m_pixmap.rect(), 5);
 			m_selectionEffectImageIsDirty = false;
 		}
 
 		painter->drawImage(boundingRectangle.topLeft(), m_selectionEffectImage, m_pixmap.rect());
 		return;
 	}
 }
 
 void HistogramPrivate::drawSymbols(QPainter* painter) {
 	QPainterPath path = Symbol::pathFromStyle(symbolsStyle);
 
 	QTransform trafo;
 	trafo.scale(symbolsSize, symbolsSize);
 	path = trafo.map(path);
 	trafo.reset();
 	if (symbolsRotationAngle != 0) {
 		trafo.rotate(-symbolsRotationAngle);
 		path = trafo.map(path);
 	}
 	for (const auto& point : symbolPointsScene) {
 		trafo.reset();
 		trafo.translate(point.x(), point.y());
 		painter->drawPath(trafo.map(path));
 	}
 }
 
 void HistogramPrivate::drawValues(QPainter* painter) {
 	QTransform trafo;
 	QPainterPath path;
 	for (int i=0; i<valuesPoints.size(); i++) {
 		path = QPainterPath();
 		path.addText( QPoint(0,0), valuesFont, valuesStrings.at(i) );
 
 		trafo.reset();
 		trafo.translate( valuesPoints.at(i).x(), valuesPoints.at(i).y() );
 		if (valuesRotationAngle!=0)
 			trafo.rotate(-valuesRotationAngle );
 
 		painter->drawPath(trafo.map(path));
 	}
 }
 
 void HistogramPrivate::drawFilling(QPainter* painter) {
 	for (const auto& pol : fillPolygons) {
 		QRectF rect = pol.boundingRect();
 		if (fillingType == PlotArea::Color) {
 			switch (fillingColorStyle) {
 			case PlotArea::SingleColor: {
 				painter->setBrush(QBrush(fillingFirstColor));
 				break;
 			}
 			case PlotArea::HorizontalLinearGradient: {
 				QLinearGradient linearGrad(rect.topLeft(), rect.topRight());
 				linearGrad.setColorAt(0, fillingFirstColor);
 				linearGrad.setColorAt(1, fillingSecondColor);
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 			case PlotArea::VerticalLinearGradient: {
 				QLinearGradient linearGrad(rect.topLeft(), rect.bottomLeft());
 				linearGrad.setColorAt(0, fillingFirstColor);
 				linearGrad.setColorAt(1, fillingSecondColor);
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 			case PlotArea::TopLeftDiagonalLinearGradient: {
 				QLinearGradient linearGrad(rect.topLeft(), rect.bottomRight());
 				linearGrad.setColorAt(0, fillingFirstColor);
 				linearGrad.setColorAt(1, fillingSecondColor);
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 			case PlotArea::BottomLeftDiagonalLinearGradient: {
 				QLinearGradient linearGrad(rect.bottomLeft(), rect.topRight());
 				linearGrad.setColorAt(0, fillingFirstColor);
 				linearGrad.setColorAt(1, fillingSecondColor);
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 			case PlotArea::RadialGradient: {
 				QRadialGradient radialGrad(rect.center(), rect.width()/2);
 				radialGrad.setColorAt(0, fillingFirstColor);
 				radialGrad.setColorAt(1, fillingSecondColor);
 				painter->setBrush(QBrush(radialGrad));
 				break;
 			}
 			}
 		} else if (fillingType == PlotArea::Image) {
 			if ( !fillingFileName.trimmed().isEmpty() ) {
 				QPixmap pix(fillingFileName);
 				switch (fillingImageStyle) {
 				case PlotArea::ScaledCropped:
 					pix = pix.scaled(rect.size().toSize(),Qt::KeepAspectRatioByExpanding,Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2,pix.size().height()/2);
 					break;
 				case PlotArea::Scaled:
 					pix = pix.scaled(rect.size().toSize(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2,pix.size().height()/2);
 					break;
 				case PlotArea::ScaledAspectRatio:
 					pix = pix.scaled(rect.size().toSize(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2,pix.size().height()/2);
 					break;
 				case PlotArea::Centered: {
 					QPixmap backpix(rect.size().toSize());
 					backpix.fill();
 					QPainter p(&backpix);
 					p.drawPixmap(QPointF(0,0),pix);
 					p.end();
 					painter->setBrush(QBrush(backpix));
 					painter->setBrushOrigin(-pix.size().width()/2,-pix.size().height()/2);
 					break;
 				}
 				case PlotArea::Tiled:
 					painter->setBrush(QBrush(pix));
 					break;
 				case PlotArea::CenterTiled:
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2,pix.size().height()/2);
 				}
 			}
 		} else if (fillingType == PlotArea::Pattern)
 			painter->setBrush(QBrush(fillingFirstColor,fillingBrushStyle));
 
 		painter->drawPolygon(pol);
 	}
 }
 
 void HistogramPrivate::hoverEnterEvent(QGraphicsSceneHoverEvent*) {
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(q->parentAspect());
 	if (plot->mouseMode() == CartesianPlot::SelectionMode && !isSelected()) {
 		m_hovered = true;
 		emit q->hovered();
 		update();
 	}
 }
 
 void HistogramPrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent*) {
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(q->parentAspect());
 	if (plot->mouseMode() == CartesianPlot::SelectionMode && m_hovered) {
 		m_hovered = false;
 		emit q->unhovered();
 		update();
 	}
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void Histogram::save(QXmlStreamWriter* writer) const {
 	Q_D(const Histogram);
 
 	writer->writeStartElement("Histogram");
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//general
 	writer->writeStartElement("general");
 	WRITE_COLUMN(d->dataColumn, dataColumn);
 	writer->writeAttribute( "type", QString::number(d->type) );
 	writer->writeAttribute( "orientation", QString::number(d->orientation) );
 	writer->writeAttribute( "binningMethod", QString::number(d->binningMethod) );
 	writer->writeAttribute( "binCount", QString::number(d->binCount));
 	writer->writeAttribute( "binWidth", QString::number(d->binWidth));
 	writer->writeAttribute( "autoBinRanges", QString::number(d->autoBinRanges) );
 	writer->writeAttribute( "binRangesMin", QString::number(d->binRangesMin) );
 	writer->writeAttribute( "binRangesMax", QString::number(d->binRangesMax) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//Line
 	writer->writeStartElement("line");
 	writer->writeAttribute( "type", QString::number(d->lineType) );
 	WRITE_QPEN(d->linePen);
 	writer->writeAttribute( "opacity", QString::number(d->lineOpacity) );
 	writer->writeEndElement();
 
 	//Symbols
 	writer->writeStartElement( "symbols" );
 	writer->writeAttribute( "symbolsStyle", QString::number(d->symbolsStyle) );
 	writer->writeAttribute( "opacity", QString::number(d->symbolsOpacity) );
 	writer->writeAttribute( "rotation", QString::number(d->symbolsRotationAngle) );
 	writer->writeAttribute( "size", QString::number(d->symbolsSize) );
 	WRITE_QBRUSH(d->symbolsBrush);
 	WRITE_QPEN(d->symbolsPen);
 	writer->writeEndElement();
 
 	//Values
 	writer->writeStartElement("values");
 	writer->writeAttribute( "type", QString::number(d->valuesType) );
 	WRITE_COLUMN(d->valuesColumn, valuesColumn);
 	writer->writeAttribute( "position", QString::number(d->valuesPosition) );
 	writer->writeAttribute( "distance", QString::number(d->valuesDistance) );
 	writer->writeAttribute( "rotation", QString::number(d->valuesRotationAngle) );
 	writer->writeAttribute( "opacity", QString::number(d->valuesOpacity) );
 	//TODO values format and precision
 	writer->writeAttribute( "prefix", d->valuesPrefix );
 	writer->writeAttribute( "suffix", d->valuesSuffix );
 	WRITE_QCOLOR(d->valuesColor);
 	WRITE_QFONT(d->valuesFont);
 	writer->writeEndElement();
 
 	//Filling
 	writer->writeStartElement("filling");
 	writer->writeAttribute( "enalbed", QString::number(d->fillingEnabled) );
 	writer->writeAttribute( "type", QString::number(d->fillingType) );
 	writer->writeAttribute( "colorStyle", QString::number(d->fillingColorStyle) );
 	writer->writeAttribute( "imageStyle", QString::number(d->fillingImageStyle) );
 	writer->writeAttribute( "brushStyle", QString::number(d->fillingBrushStyle) );
 	writer->writeAttribute( "firstColor_r", QString::number(d->fillingFirstColor.red()) );
 	writer->writeAttribute( "firstColor_g", QString::number(d->fillingFirstColor.green()) );
 	writer->writeAttribute( "firstColor_b", QString::number(d->fillingFirstColor.blue()) );
 	writer->writeAttribute( "secondColor_r", QString::number(d->fillingSecondColor.red()) );
 	writer->writeAttribute( "secondColor_g", QString::number(d->fillingSecondColor.green()) );
 	writer->writeAttribute( "secondColor_b", QString::number(d->fillingSecondColor.blue()) );
 	writer->writeAttribute( "fileName", d->fillingFileName );
 	writer->writeAttribute( "opacity", QString::number(d->fillingOpacity) );
 	writer->writeEndElement();
 
 	writer->writeEndElement(); //close "Histogram" section
 }
 
 //! Load from XML
 bool Histogram::load(XmlStreamReader* reader, bool preview) {
 	Q_D(Histogram);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "Histogram")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (!preview && reader->name() == "general") {
 			attribs = reader->attributes();
 
 			READ_COLUMN(dataColumn);
 			READ_INT_VALUE("type", type, Histogram::HistogramType);
 			READ_INT_VALUE("orientation", orientation, Histogram::HistogramOrientation);
 			READ_INT_VALUE("binningMethod", binningMethod, Histogram::BinningMethod);
 			READ_INT_VALUE("binCount", binCount, int);
 			READ_DOUBLE_VALUE("binWidth", binWidth);
 			READ_INT_VALUE("autoBinRanges", autoBinRanges, bool);
 			READ_DOUBLE_VALUE("binRangesMin", binRangesMin);
 			READ_DOUBLE_VALUE("binRangesMax", binRangesMax);
 
 			str = attribs.value("visible").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (!preview && reader->name() == "line") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", lineType, Histogram::LineType);
 			READ_QPEN(d->linePen);
 			READ_DOUBLE_VALUE("opacity", lineOpacity);
 		} else if (!preview && reader->name() == "symbols") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("symbolsStyle", symbolsStyle, Symbol::Style);
 			READ_DOUBLE_VALUE("opacity", symbolsOpacity);
 			READ_DOUBLE_VALUE("rotation", symbolsRotationAngle);
 			READ_DOUBLE_VALUE("size", symbolsSize);
 
 			READ_QBRUSH(d->symbolsBrush);
 			READ_QPEN(d->symbolsPen);
 		} else if (!preview && reader->name() == "values") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", valuesType, Histogram::ValuesType);
 			READ_COLUMN(valuesColumn);
 			READ_INT_VALUE("position", valuesPosition, Histogram::ValuesPosition);
 			READ_DOUBLE_VALUE("distance", valuesRotationAngle);
 			READ_DOUBLE_VALUE("rotation", valuesRotationAngle);
 			READ_DOUBLE_VALUE("opacity", valuesOpacity);
 
 			//don't produce any warning if no prefix or suffix is set (empty string is allowed here in xml)
 			d->valuesPrefix = attribs.value("prefix").toString();
 			d->valuesSuffix = attribs.value("suffix").toString();
 
 			READ_QCOLOR(d->valuesColor);
 			READ_QFONT(d->valuesFont);
 		} else if (!preview && reader->name() == "filling") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("enabled", fillingEnabled, bool);
 			READ_INT_VALUE("type", fillingType, PlotArea::BackgroundType);
 			READ_INT_VALUE("colorStyle", fillingColorStyle, PlotArea::BackgroundColorStyle);
 			READ_INT_VALUE("imageStyle", fillingImageStyle, PlotArea::BackgroundImageStyle);
 			READ_INT_VALUE("brushStyle", fillingBrushStyle, Qt::BrushStyle);
 
 			str = attribs.value("firstColor_r").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_r").toString());
 			else
 				d->fillingFirstColor.setRed(str.toInt());
 
 			str = attribs.value("firstColor_g").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_g").toString());
 			else
 				d->fillingFirstColor.setGreen(str.toInt());
 
 			str = attribs.value("firstColor_b").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_b").toString());
 			else
 				d->fillingFirstColor.setBlue(str.toInt());
 
 			str = attribs.value("secondColor_r").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_r").toString());
 			else
 				d->fillingSecondColor.setRed(str.toInt());
 
 			str = attribs.value("secondColor_g").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_g").toString());
 			else
 				d->fillingSecondColor.setGreen(str.toInt());
 
 			str = attribs.value("secondColor_b").toString();
 			if(str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_b").toString());
 			else
 				d->fillingSecondColor.setBlue(str.toInt());
 
 			d->fillingFileName = attribs.value("fileName").toString();
 			READ_DOUBLE_VALUE("opacity", fillingOpacity);
 		} else if(reader->name() == "column") {
 			Column* column = new Column("", AbstractColumn::Numeric);
 			if (!column->load(reader, preview)) {
 				delete column;
 				return false;
 			}
 			d->dataColumn = column;
 		}
 	}
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void Histogram::loadThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("XYCurve");
 
 	int index = parentAspect()->indexOfChild<Histogram>(this);
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(parentAspect());
 	QColor themeColor;
 	if (index<plot->themeColorPalette().size())
 		themeColor = plot->themeColorPalette().at(index);
 	else {
 		if (plot->themeColorPalette().size())
 			themeColor = plot->themeColorPalette().last();
 	}
 
 	QPen p;
 
 	Q_D(Histogram);
 	d->m_suppressRecalc = true;
 
 	//Line
 	p.setStyle((Qt::PenStyle)group.readEntry("LineStyle", (int)this->linePen().style()));
 	p.setWidthF(group.readEntry("LineWidth", this->linePen().widthF()));
 	p.setColor(themeColor);
 	this->setLinePen(p);
 	this->setLineOpacity(group.readEntry("LineOpacity", this->lineOpacity()));
 
 	//Symbol
 	this->setSymbolsOpacity(group.readEntry("SymbolOpacity", this->symbolsOpacity()));
 	QBrush brush = symbolsBrush();
 	brush.setColor(themeColor);
 	this->setSymbolsBrush(brush);
 	p = symbolsPen();
 	p.setColor(themeColor);
 	this->setSymbolsPen(p);
 
 	//Values
 	this->setValuesOpacity(group.readEntry("ValuesOpacity", this->valuesOpacity()));
 	this->setValuesColor(group.readEntry("ValuesColor", this->valuesColor()));
 
 	//Filling
 	this->setFillingBrushStyle((Qt::BrushStyle)group.readEntry("FillingBrushStyle",(int) this->fillingBrushStyle()));
 	this->setFillingColorStyle((PlotArea::BackgroundColorStyle)group.readEntry("FillingColorStyle",(int) this->fillingColorStyle()));
 	this->setFillingOpacity(group.readEntry("FillingOpacity", this->fillingOpacity()));
 	this->setFillingSecondColor(group.readEntry("FillingSecondColor",(QColor) this->fillingSecondColor()));
 	this->setFillingFirstColor(themeColor);
 	this->setFillingType((PlotArea::BackgroundType)group.readEntry("FillingType",(int) this->fillingType()));
 
 	//Error Bars
 	//TODO:
 // 	p.setStyle((Qt::PenStyle)group.readEntry("ErrorBarsStyle",(int) this->errorBarsPen().style()));
 // 	p.setWidthF(group.readEntry("ErrorBarsWidth", this->errorBarsPen().widthF()));
 // 	p.setColor(themeColor);
 // 	this->setErrorBarsPen(p);
 // 	this->setErrorBarsOpacity(group.readEntry("ErrorBarsOpacity",this->errorBarsOpacity()));
 
 	d->m_suppressRecalc = false;
 	d->recalcShapeAndBoundingRect();
 }
 
 void Histogram::saveThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("Histogram");
 
 	//Line
 	group.writeEntry("LineOpacity", this->lineOpacity());
 	group.writeEntry("LineStyle",(int) this->linePen().style());
 	group.writeEntry("LineWidth", this->linePen().widthF());
 
 	//Error Bars
 // 	group.writeEntry("ErrorBarsCapSize",this->errorBarsCapSize());
 // 	group.writeEntry("ErrorBarsOpacity",this->errorBarsOpacity());
 // 	group.writeEntry("ErrorBarsColor",(QColor) this->errorBarsPen().color());
 // 	group.writeEntry("ErrorBarsStyle",(int) this->errorBarsPen().style());
 // 	group.writeEntry("ErrorBarsWidth", this->errorBarsPen().widthF());
 
 	//Filling
 	group.writeEntry("FillingBrushStyle",(int) this->fillingBrushStyle());
 	group.writeEntry("FillingColorStyle",(int) this->fillingColorStyle());
 	group.writeEntry("FillingOpacity", this->fillingOpacity());
 	group.writeEntry("FillingSecondColor",(QColor) this->fillingSecondColor());
 	group.writeEntry("FillingType",(int) this->fillingType());
 
 	//Symbol
 	group.writeEntry("SymbolOpacity", this->symbolsOpacity());
 
 	//Values
 	group.writeEntry("ValuesOpacity", this->valuesOpacity());
 	group.writeEntry("ValuesColor", (QColor) this->valuesColor());
 	group.writeEntry("ValuesFont", this->valuesFont());
 
 	int index = parentAspect()->indexOfChild<Histogram>(this);
 	if(index<5) {
 		KConfigGroup themeGroup = config.group("Theme");
 		for(int i = index; i<5; i++) {
 			QString s = "ThemePaletteColor" + QString::number(i+1);
 			themeGroup.writeEntry(s,(QColor) this->linePen().color());
 		}
 	}
 }
diff --git a/src/commonfrontend/ProjectExplorer.cpp b/src/commonfrontend/ProjectExplorer.cpp
index 6557285c2..0d4acdde0 100644
--- a/src/commonfrontend/ProjectExplorer.cpp
+++ b/src/commonfrontend/ProjectExplorer.cpp
@@ -1,851 +1,851 @@
 
 /***************************************************************************
     File                 : ProjectExplorer.cpp
     Project              : LabPlot
     Description       	 : A tree view for displaying and editing an AspectTreeModel.
     --------------------------------------------------------------------
     Copyright            : (C) 2007-2008 by Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2010-2018 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ProjectExplorer.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/AbstractPart.h"
 #include "backend/core/Project.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "commonfrontend/core/PartMdiView.h"
 
 #include <QContextMenuEvent>
 #include <QDrag>
 #include <QHeaderView>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QMimeData>
 #include <QPushButton>
 #include <QSignalMapper>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 /*!
   \class ProjectExplorer
   \brief A tree view for displaying and editing an AspectTreeModel.
 
   In addition to the functionality of QTreeView, ProjectExplorer allows
   the usage of the context menus provided by AspectTreeModel
   and propagates the item selection in the view to the model.
   Furthermore, features for searching and filtering in the model are provided.
 
   \ingroup commonfrontend
 */
 
 ProjectExplorer::ProjectExplorer(QWidget* parent) : m_columnToHide(0),
 	m_treeView(new QTreeView(parent)),
 	m_project(nullptr),
 	m_dragStarted(false),
 	m_frameFilter(new QFrame(this))  {
 
 	QVBoxLayout* layout = new QVBoxLayout(this);
 	layout->setSpacing(0);
 	layout->setContentsMargins(0, 0, 0, 0);
 
 	QHBoxLayout* layoutFilter= new QHBoxLayout(m_frameFilter);
 	layoutFilter->setSpacing(0);
 	layoutFilter->setContentsMargins(0, 0, 0, 0);
 
 	QLabel* lFilter = new QLabel(i18n("Search/Filter:"));
 	layoutFilter->addWidget(lFilter);
 
 	m_leFilter = new QLineEdit(m_frameFilter);
 	m_leFilter->setClearButtonEnabled(true);
 	m_leFilter->setPlaceholderText(i18n("Search/Filter text"));
 	layoutFilter->addWidget(m_leFilter);
 
 	bFilterOptions = new QPushButton(m_frameFilter);
 	bFilterOptions->setIcon(QIcon::fromTheme("configure"));
 	bFilterOptions->setCheckable(true);
 	layoutFilter->addWidget(bFilterOptions);
 
 	layout->addWidget(m_frameFilter);
 
 	m_treeView->setAnimated(true);
 	m_treeView->setAlternatingRowColors(true);
 	m_treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
 	m_treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
 	m_treeView->setUniformRowHeights(true);
 	m_treeView->viewport()->installEventFilter(this);
 	m_treeView->header()->setStretchLastSection(true);
 	m_treeView->header()->installEventFilter(this);
 	m_treeView->setDragEnabled(true);
 	m_treeView->setAcceptDrops(true);
 	m_treeView->setDropIndicatorShown(true);
 	m_treeView->setDragDropMode(QAbstractItemView::InternalMove);
 
 	layout->addWidget(m_treeView);
 
 	this->createActions();
 
 	connect(m_leFilter, SIGNAL(textChanged(QString)), this, SLOT(filterTextChanged(QString)));
 	connect(bFilterOptions, SIGNAL(toggled(bool)), this, SLOT(toggleFilterOptionsMenu(bool)));
 }
 
 void ProjectExplorer::createActions() {
 	caseSensitiveAction = new QAction(i18n("Case Sensitive"), this);
 	caseSensitiveAction->setCheckable(true);
 	caseSensitiveAction->setChecked(false);
 	connect(caseSensitiveAction, SIGNAL(triggered()), this, SLOT(toggleFilterCaseSensitivity()));
 
 	matchCompleteWordAction = new QAction(i18n("Match Complete Word"), this);
 	matchCompleteWordAction->setCheckable(true);
 	matchCompleteWordAction->setChecked(false);
 	connect(matchCompleteWordAction, SIGNAL(triggered()), this, SLOT(toggleFilterMatchCompleteWord()));
 
 	expandTreeAction = new QAction(QIcon::fromTheme(QLatin1String("view-list-tree")), i18n("Expand All"), this);
 	connect(expandTreeAction, SIGNAL(triggered()), m_treeView, SLOT(expandAll()));
 
 	expandSelectedTreeAction = new QAction(QIcon::fromTheme(QLatin1String("view-list-tree")), i18n("Expand Selected"), this);
 	connect(expandSelectedTreeAction, SIGNAL(triggered()), this, SLOT(expandSelected()));
 
 	collapseTreeAction = new QAction(i18n("Collapse All"), this);
 	connect(collapseTreeAction, SIGNAL(triggered()), m_treeView, SLOT(collapseAll()));
 
 	collapseSelectedTreeAction = new QAction(i18n("Collapse Selected"), this);
 	connect(collapseSelectedTreeAction, SIGNAL(triggered()), this, SLOT(collapseSelected()));
 
 	deleteSelectedTreeAction = new QAction(QIcon::fromTheme("edit-delete"), i18n("Delete Selected"), this);
 	connect(deleteSelectedTreeAction, SIGNAL(triggered()), this, SLOT(deleteSelected()));
 
 	toggleFilterAction = new QAction(QIcon::fromTheme(QLatin1String("view-filter")), i18n("Hide Search/Filter Options"), this);
 	connect(toggleFilterAction, SIGNAL(triggered()), this, SLOT(toggleFilterWidgets()));
 
 	showAllColumnsAction = new QAction(i18n("Show All"),this);
 	showAllColumnsAction->setCheckable(true);
 	showAllColumnsAction->setChecked(true);
 	showAllColumnsAction->setEnabled(false);
 	connect(showAllColumnsAction, SIGNAL(triggered()), this, SLOT(showAllColumns()));
 }
 
 /*!
   shows the context menu in the tree. In addition to the context menu of the currently selected aspect,
   treeview specific options are added.
 */
 void ProjectExplorer::contextMenuEvent(QContextMenuEvent *event) {
 	if(!m_treeView->model())
 		return;
 
 	const QModelIndex& index = m_treeView->indexAt(m_treeView->viewport()->mapFrom(this, event->pos()));
 	if (!index.isValid())
 		m_treeView->clearSelection();
 
 	const QModelIndexList& items = m_treeView->selectionModel()->selectedIndexes();
 	QMenu* menu = nullptr;
 	if (items.size()/4 == 1) {
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		menu = aspect->createContextMenu();
 	} else {
 		menu = new QMenu();
 		if (items.size()/4 > 1) {
 			menu->addAction(expandSelectedTreeAction);
 			menu->addAction(collapseSelectedTreeAction);
 			menu->addSeparator();
 			menu->addAction(deleteSelectedTreeAction);
 			menu->addSeparator();
 		} else {
 			menu->addAction(expandTreeAction);
 			menu->addAction(collapseTreeAction);
 			menu->addSeparator();
 			menu->addAction(toggleFilterAction);
 
 			//Menu for showing/hiding the columns in the tree view
 			QMenu* columnsMenu = menu->addMenu(i18n("Show/Hide columns"));
 			columnsMenu->addAction(showAllColumnsAction);
 			columnsMenu->addSeparator();
-			for (auto action: list_showColumnActions)
+			for (auto* action : list_showColumnActions)
 				columnsMenu->addAction(action);
 
 			//TODO
 			//Menu for showing/hiding the top-level aspects (Worksheet, Spreadhsheet, etc) in the tree view
 			// QMenu* objectsMenu = menu->addMenu(i18n("Show/Hide objects"));
 		}
 	}
 	menu->exec(event->globalPos());
 	delete menu;
 }
 
 void ProjectExplorer::setCurrentAspect(const AbstractAspect* aspect) {
 	const AspectTreeModel* tree_model = qobject_cast<AspectTreeModel*>(m_treeView->model());
 	if(tree_model)
 		m_treeView->setCurrentIndex(tree_model->modelIndexOfAspect(aspect));
 }
 
 /*!
   Sets the \c model for the tree view to present.
 */
 void ProjectExplorer::setModel(AspectTreeModel* treeModel) {
 	m_treeView->setModel(treeModel);
 
 	connect(treeModel, SIGNAL(renameRequested(QModelIndex)), m_treeView, SLOT(edit(QModelIndex)));
 	connect(treeModel, SIGNAL(indexSelected(QModelIndex)), this, SLOT(selectIndex(QModelIndex)));
 	connect(treeModel, SIGNAL(indexDeselected(QModelIndex)), this, SLOT(deselectIndex(QModelIndex)));
 	connect(treeModel, SIGNAL(hiddenAspectSelected(const AbstractAspect*)), this, SIGNAL(hiddenAspectSelected(const AbstractAspect*)));
 
 	connect(m_treeView->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
 	        this, SLOT(currentChanged(QModelIndex,QModelIndex)) );
 	connect(m_treeView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 	        this, SLOT(selectionChanged(QItemSelection,QItemSelection)) );
 
 	//create action for showing/hiding the columns in the tree.
 	//this is done here since the number of columns is  not available in createActions() yet.
 	if (list_showColumnActions.size()==0) {
 		showColumnsSignalMapper = new QSignalMapper(this);
 		for (int i=0; i<m_treeView->model()->columnCount(); i++) {
 			QAction* showColumnAction =  new QAction(treeModel->headerData(i, Qt::Horizontal).toString(), this);
 			showColumnAction->setCheckable(true);
 			showColumnAction->setChecked(true);
 			list_showColumnActions.append(showColumnAction);
 
 			connect(showColumnAction, SIGNAL(triggered(bool)), showColumnsSignalMapper, SLOT(map()));
 			showColumnsSignalMapper->setMapping(showColumnAction, i);
 		}
 		connect(showColumnsSignalMapper, SIGNAL(mapped(int)), this, SLOT(toggleColumn(int)));
 	} else {
 		for (int i=0; i<list_showColumnActions.size(); ++i) {
 			if (!list_showColumnActions.at(i)->isChecked())
 				m_treeView->hideColumn(i);
 		}
 	}
 }
 
 void ProjectExplorer::setProject(Project* project) {
 	connect(project, SIGNAL(aspectAdded(const AbstractAspect*)), this, SLOT(aspectAdded(const AbstractAspect*)));
 	connect(project, SIGNAL(requestSaveState(QXmlStreamWriter*)), this, SLOT(save(QXmlStreamWriter*)));
 	connect(project, SIGNAL(requestLoadState(XmlStreamReader*)), this, SLOT(load(XmlStreamReader*)));
 	connect(project, SIGNAL(requestNavigateTo(QString)), this, SLOT(navigateTo(QString)));
 	connect(project, SIGNAL(loaded()), this, SLOT(resizeHeader()));
 	m_project = project;
 
 	//for newly created projects, resize the header to fit the size of the header section names.
 	//for projects loaded from a file, this function will be called laterto fit the sizes
 	//of the content once the project is loaded
 	resizeHeader();
 }
 
 QModelIndex ProjectExplorer::currentIndex() const {
 	return m_treeView->currentIndex();
 }
 
 /*!
 	handles the contextmenu-event of the horizontal header in the tree view.
 	Provides a menu for selective showing and hiding of columns.
 */
 bool ProjectExplorer::eventFilter(QObject* obj, QEvent* event) {
 	if (obj == m_treeView->header() && event->type() == QEvent::ContextMenu) {
 		//Menu for showing/hiding the columns in the tree view
 		QMenu* columnsMenu = new QMenu(m_treeView->header());
 		columnsMenu->addSection(i18n("Columns"));
 		columnsMenu->addAction(showAllColumnsAction);
 		columnsMenu->addSeparator();
-		for (auto action: list_showColumnActions)
+		for (auto* action : list_showColumnActions)
 			columnsMenu->addAction(action);
 
 		QContextMenuEvent* e = static_cast<QContextMenuEvent*>(event);
 		columnsMenu->exec(e->globalPos());
 		delete columnsMenu;
 
 		return true;
 	} else if (obj == m_treeView->viewport()) {
 		QMouseEvent* e = static_cast<QMouseEvent*>(event);
 		if (event->type() == QEvent::MouseButtonPress) {
 			if (e->button() == Qt::LeftButton) {
 				m_dragStartPos = e->globalPos();
 				m_dragStarted = false;
 			}
 		} else if (event->type() == QEvent::MouseMove) {
 			if ( !m_dragStarted && m_treeView->selectionModel()->selectedIndexes().size() > 0
 				&& (e->globalPos() - m_dragStartPos).manhattanLength() >= QApplication::startDragDistance()) {
 
 				m_dragStarted = true;
 				QDrag* drag = new QDrag(this);
 				QMimeData* mimeData = new QMimeData;
 
 				//determine the selected objects and serialize the pointers to QMimeData
 				QVector<quintptr> vec;
 				QModelIndexList items = m_treeView->selectionModel()->selectedIndexes();
 				//there are four model indices in each row -> divide by 4 to obtain the number of selected rows (=aspects)
 				for (int i = 0; i < items.size()/4; ++i) {
 					const QModelIndex& index = items.at(i*4);
 					AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 					vec << (quintptr)aspect;
 				}
 
 				QByteArray data;
 				QDataStream stream(&data, QIODevice::WriteOnly);
 				stream << vec;
 
 				mimeData->setData("labplot-dnd", data);
 				drag->setMimeData(mimeData);
 				drag->exec();
 			}
 		}
 		else if (event->type() == QEvent::DragEnter) {
 			//ignore events not related to internal drags of columns etc., e.g. dropping of external files onto LabPlot
 			QDragEnterEvent* dragEnterEvent = static_cast<QDragEnterEvent*>(event);
 			const QMimeData* mimeData = dragEnterEvent->mimeData();
 			if (!mimeData) {
 				event->ignore();
 				return false;
 			}
 
 			if (mimeData->formats().at(0) != QLatin1String("labplot-dnd")) {
 				event->ignore();
 				return false;
 			}
 
 			event->setAccepted(true);
 		} else if (event->type() == QEvent::DragMove) {
 			// only accept drop events if we have a plot under the cursor where we can drop columns onto
 			QDragMoveEvent* dragMoveEvent = static_cast<QDragMoveEvent*>(event);
 			QModelIndex index = m_treeView->indexAt(dragMoveEvent->pos());
 			if (!index.isValid())
 				return false;
 
 			AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 			const bool isPlot = (dynamic_cast<CartesianPlot*>(aspect) != nullptr);
 			event->setAccepted(isPlot);
 		} else if (event->type() == QEvent::Drop) {
 			QDropEvent* dropEvent = static_cast<QDropEvent*>(event);
 			QModelIndex index = m_treeView->indexAt(dropEvent->pos());
 			if (!index.isValid())
 				return false;
 
 			AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(aspect);
 			if (plot != nullptr)
 				plot->processDropEvent(dropEvent);
 		}
 	}
 
 	return QObject::eventFilter(obj, event);
 }
 
 //##############################################################################
 //#################################  SLOTS  ####################################
 //##############################################################################
 
 /*!
   expand the aspect \c aspect (the tree index corresponding to it) in the tree view
   and makes it visible and selected. Called when a new aspect is added to the project.
  */
 void ProjectExplorer::aspectAdded(const AbstractAspect* aspect) {
 	if (m_project->isLoading())
 		return;
 
 	//don't do anything if hidden aspects were added
 	if (aspect->hidden())
 		return;
 
 
 	//don't do anything for newly added data spreadsheets of data picker curves
 	if (aspect->inherits("Spreadsheet") && aspect->parentAspect()->inherits("DatapickerCurve"))
 		return;
 
 	const AspectTreeModel* tree_model = qobject_cast<AspectTreeModel*>(m_treeView->model());
 	const QModelIndex& index =  tree_model->modelIndexOfAspect(aspect);
 
 	//expand and make the aspect visible
 	m_treeView->setExpanded(index, true);
 
 	// newly added columns are only expanded but not selected, return here
 	if ( aspect->inherits("Column") ) {
 		m_treeView->setExpanded(tree_model->modelIndexOfAspect(aspect->parentAspect()), true);
 		return;
 	}
 
 	m_treeView->scrollTo(index);
 	m_treeView->setCurrentIndex(index);
 	m_treeView->header()->resizeSections(QHeaderView::ResizeToContents);
 	m_treeView->header()->resizeSection(0, m_treeView->header()->sectionSize(0)*1.2);
 }
 
 void ProjectExplorer::navigateTo(const QString& path) {
 	const AspectTreeModel* tree_model = qobject_cast<AspectTreeModel*>(m_treeView->model());
 	if(tree_model)
 		m_treeView->setCurrentIndex(tree_model->modelIndexOfAspect(path));
 }
 
 void ProjectExplorer::currentChanged(const QModelIndex & current, const QModelIndex & previous) {
 	Q_UNUSED(previous);
 	emit currentAspectChanged(static_cast<AbstractAspect*>(current.internalPointer()));
 }
 
 void ProjectExplorer::toggleColumn(int index) {
 	//determine the total number of checked column actions
 	int checked = 0;
 	for (const auto* action : list_showColumnActions) {
 		if (action->isChecked())
 			checked++;
 	}
 
 	if (list_showColumnActions.at(index)->isChecked()) {
 		m_treeView->showColumn(index);
 		m_treeView->header()->resizeSection(0,0 );
 		m_treeView->header()->resizeSections(QHeaderView::ResizeToContents);
 
 		for (auto* action : list_showColumnActions)
 			action->setEnabled(true);
 
 		//deactivate the "show all column"-action, if all actions are checked
 		if ( checked == list_showColumnActions.size() ) {
 			showAllColumnsAction->setEnabled(false);
 			showAllColumnsAction->setChecked(true);
 		}
 	} else {
 		m_treeView->hideColumn(index);
 		showAllColumnsAction->setEnabled(true);
 		showAllColumnsAction->setChecked(false);
 
 		//if there is only one checked column-action, deactivated it.
 		//It should't be possible to hide all columns
 		if ( checked == 1 ) {
 			int i=0;
 			while( !list_showColumnActions.at(i)->isChecked() )
 				i++;
 
 			list_showColumnActions.at(i)->setEnabled(false);
 		}
 	}
 }
 
 void ProjectExplorer::showAllColumns() {
 	for (int i=0; i<m_treeView->model()->columnCount(); i++) {
 		m_treeView->showColumn(i);
 		m_treeView->header()->resizeSection(0,0 );
 		m_treeView->header()->resizeSections(QHeaderView::ResizeToContents);
 	}
 	showAllColumnsAction->setEnabled(false);
 
 	for (auto* action : list_showColumnActions) {
 		action->setEnabled(true);
 		action->setChecked(true);
 	}
 }
 
 /*!
   shows/hides the frame with the search/filter widgets
 */
 void ProjectExplorer::toggleFilterWidgets() {
 	if (m_frameFilter->isVisible()) {
 		m_frameFilter->hide();
 		toggleFilterAction->setText(i18n("Show Search/Filter Options"));
 	} else {
 		m_frameFilter->show();
 		toggleFilterAction->setText(i18n("Hide Search/Filter Options"));
 	}
 }
 
 /*!
   toggles the menu for the filter/search options
 */
 void ProjectExplorer::toggleFilterOptionsMenu(bool checked) {
 	if (checked) {
 		QMenu menu;
 		menu.addAction(caseSensitiveAction);
 		menu.addAction(matchCompleteWordAction);
 		connect(&menu, SIGNAL(aboutToHide()), bFilterOptions, SLOT(toggle()));
 		menu.exec(bFilterOptions->mapToGlobal(QPoint(0,bFilterOptions->height())));
 	}
 }
 
 void ProjectExplorer::resizeHeader() {
 	m_treeView->header()->resizeSections(QHeaderView::ResizeToContents);
 	m_treeView->header()->resizeSection(0, m_treeView->header()->sectionSize(0)*1.2); //make the column "Name" somewhat bigger
 }
 
 /*!
   called when the filter/search text was changend.
 */
 void ProjectExplorer::filterTextChanged(const QString& text) {
 	QModelIndex root = m_treeView->model()->index(0,0);
 	filter(root, text);
 }
 
 bool ProjectExplorer::filter(const QModelIndex& index, const QString& text) {
 	Qt::CaseSensitivity sensitivity = caseSensitiveAction->isChecked() ? Qt::CaseSensitive : Qt::CaseInsensitive;
 	bool matchCompleteWord = matchCompleteWordAction->isChecked();
 
 	bool childVisible = false;
 	const int rows = index.model()->rowCount(index);
 	for (int i=0; i<rows; i++) {
 		QModelIndex child = index.child(i, 0);
 		AbstractAspect* aspect =  static_cast<AbstractAspect*>(child.internalPointer());
 		bool visible;
 		if(text.isEmpty())
 			visible = true;
 		else if (matchCompleteWord)
 			visible = aspect->name().startsWith(text, sensitivity);
 		else
 			visible = aspect->name().contains(text, sensitivity);
 
 		if (visible) {
 			//current item is visible -> make all its children visible without applying the filter
 			for (int j=0; j<child.model()->rowCount(child); ++j) {
 				m_treeView->setRowHidden(j, child, false);
 				if(text.isEmpty())
 					filter(child, text);
 			}
 
 			childVisible = true;
 		} else {
 			//check children items. if one of the children is visible, make the parent (current) item visible too.
 			visible = filter(child, text);
 			if (visible)
 				childVisible = true;
 		}
 
 		m_treeView->setRowHidden(i, index, !visible);
 	}
 
 	return childVisible;
 }
 
 void ProjectExplorer::toggleFilterCaseSensitivity() {
 	filterTextChanged(m_leFilter->text());
 }
 
 void ProjectExplorer::toggleFilterMatchCompleteWord() {
 	filterTextChanged(m_leFilter->text());
 }
 
 void ProjectExplorer::selectIndex(const QModelIndex&  index) {
 	if (m_project->isLoading())
 		return;
 
 	if ( !m_treeView->selectionModel()->isSelected(index) ) {
 		m_treeView->selectionModel()->select(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
 		m_treeView->setExpanded(index, true);
 		m_treeView->scrollTo(index);
 	}
 }
 
 void ProjectExplorer::deselectIndex(const QModelIndex & index) {
 	if (m_project->isLoading())
 		return;
 
 	if ( m_treeView->selectionModel()->isSelected(index) )
 		m_treeView->selectionModel()->select(index, QItemSelectionModel::Deselect | QItemSelectionModel::Rows);
 }
 
 void ProjectExplorer::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected) {
 	QModelIndex index;
 	QModelIndexList items;
 	AbstractAspect* aspect = nullptr;
 
 	//there are four model indices in each row
 	//-> divide by 4 to obtain the number of selected rows (=aspects)
 	items = selected.indexes();
 	for (int i=0; i<items.size()/4; ++i) {
 		index = items.at(i*4);
 		aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		aspect->setSelected(true);
 	}
 
 	items = deselected.indexes();
 	for (int i = 0; i < items.size()/4; ++i) {
 		index = items.at(i*4);
 		aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		aspect->setSelected(false);
 	}
 
 	items = m_treeView->selectionModel()->selectedRows();
 	QList<AbstractAspect*> selectedAspects;
 	for (const QModelIndex& index : items) {
 		aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		selectedAspects<<aspect;
 	}
 
 	emit selectedAspectsChanged(selectedAspects);
 }
 
 void ProjectExplorer::expandSelected() {
 	const QModelIndexList items = m_treeView->selectionModel()->selectedIndexes();
 	for (const auto& index : items)
 		m_treeView->setExpanded(index, true);
 }
 
 void ProjectExplorer::collapseSelected() {
 	const QModelIndexList items = m_treeView->selectionModel()->selectedIndexes();
 	for (const auto& index : items)
 		m_treeView->setExpanded(index, false);
 }
 
 void ProjectExplorer::deleteSelected() {
 	const QModelIndexList items = m_treeView->selectionModel()->selectedIndexes();
 	if (!items.size())
 		return;
 
 
 	int rc = KMessageBox::warningYesNo( this,
 	                                    i18np("Do you really want to delete the selected object?", "Do you really want to delete the selected %1 objects?", items.size()/4),
 	                                    i18np("Delete selected object", "Delete selected objects", items.size()/4));
 
 	if (rc == KMessageBox::No)
 		return;
 
 	m_project->beginMacro(i18np("Project Explorer: delete %1 selected object", "Project Explorer: delete %1 selected objects", items.size()/4));
 	for (int i = 0; i < items.size()/4; ++i) {
 		const QModelIndex& index = items.at(i*4);
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		aspect->remove();
 	}
 	m_project->endMacro();
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 struct ViewState {
 	Qt::WindowStates state;
 	QRect geometry;
 };
 
 /**
  * \brief Save the current state of the tree view
  * (expanded items and the currently selected item) as XML
  */
 void ProjectExplorer::save(QXmlStreamWriter* writer) const {
 	AspectTreeModel* model = qobject_cast<AspectTreeModel*>(m_treeView->model());
 	QList<int> selected;
 	QList<int> expanded;
 	QList<int> withView;
 	QVector<ViewState> viewStates;
 
 	int currentRow = -1; //row corresponding to the current index in the tree view, -1 for the root element (=project)
 	QModelIndexList selectedRows = m_treeView->selectionModel()->selectedRows();
 
 	//check whether the project node itself is expanded
 	if (m_treeView->isExpanded(m_treeView->model()->index(0,0)))
 		expanded.push_back(-1);
 
 	int row = 0;
 	QVector<AbstractAspect*> aspects = const_cast<Project*>(m_project)->children("AbstractAspect", AbstractAspect::Recursive);
 	for (const auto* aspect : aspects) {
 		const QModelIndex& index = model->modelIndexOfAspect(aspect);
 
 		const AbstractPart* part = dynamic_cast<const AbstractPart*>(aspect);
 		if (part && part->hasMdiSubWindow()) {
 			withView.push_back(row);
 			ViewState s = {part->view()->windowState(), part->view()->geometry()};
 			viewStates.push_back(s);
 		}
 
 		if (model->rowCount(index)>0 && m_treeView->isExpanded(index))
 			expanded.push_back(row);
 
 		if (selectedRows.indexOf(index) != -1)
 			selected.push_back(row);
 
 		if (index == m_treeView->currentIndex())
 			currentRow = row;
 
 		row++;
 	}
 
 	writer->writeStartElement("state");
 
 	writer->writeStartElement("expanded");
-	for (auto e: expanded)
+	for (const auto e : expanded)
 		writer->writeTextElement("row", QString::number(e));
 	writer->writeEndElement();
 
 	writer->writeStartElement("selected");
-	for (auto s: selected)
+	for (const auto s : selected)
 		writer->writeTextElement("row", QString::number(s));
 	writer->writeEndElement();
 
 	writer->writeStartElement("view");
 	for (int i = 0; i < withView.size(); ++i) {
 		writer->writeStartElement("row");
 		const ViewState& s = viewStates.at(i);
 		writer->writeAttribute( "state", QString::number(s.state) );
 		writer->writeAttribute( "x", QString::number(s.geometry.x()) );
 		writer->writeAttribute( "y", QString::number(s.geometry.y()) );
 		writer->writeAttribute( "width", QString::number(s.geometry.width()) );
 		writer->writeAttribute( "height", QString::number(s.geometry.height()) );
 		writer->writeCharacters(QString::number(withView.at(i)));
 		writer->writeEndElement();
 	}
 	writer->writeEndElement();
 
 	writer->writeStartElement("current");
 	writer->writeTextElement("row", QString::number(currentRow));
 	writer->writeEndElement();
 
 	writer->writeEndElement();
 }
 
 /**
  * \brief Load from XML
  */
 bool ProjectExplorer::load(XmlStreamReader* reader) {
 	const AspectTreeModel* model = qobject_cast<AspectTreeModel*>(m_treeView->model());
 	const QVector<AbstractAspect*> aspects = const_cast<Project*>(m_project)->children("AbstractAspect", AbstractAspect::Recursive);
 
 	bool expandedItem = false;
 	bool selectedItem = false;
 	bool viewItem = false;
 	(void)viewItem; // because of a strange g++-warning about unused viewItem
 	bool currentItem = false;
 	QModelIndex currentIndex;
 	QString str;
 	int row;
 	QVector<QModelIndex> selected;
 	QList<QModelIndex> expanded;
 	QXmlStreamAttributes attribs;
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "state")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "expanded") {
 			expandedItem = true;
 			selectedItem = false;
 			viewItem = false;
 			currentItem = false;
 		} else if (reader->name() == "selected") {
 			expandedItem = false;
 			selectedItem = true;
 			viewItem = false;
 			currentItem = false;
 		} else 	if (reader->name() == "view") {
 			expandedItem = false;
 			selectedItem = false;
 			viewItem = true;
 			currentItem = false;
 		} else 	if (reader->name() == "current") {
 			expandedItem = false;
 			selectedItem = false;
 			viewItem = false;
 			currentItem = true;
 		} else if (reader->name() == "row") {
 			attribs = reader->attributes();
 			row = reader->readElementText().toInt();
 
 			QModelIndex index;
 			if (row == -1)
 				index = model->modelIndexOfAspect(m_project); //-1 corresponds to the project-item (s.a. ProjectExplorer::save())
 			else if (row >= aspects.size())
 				continue;
 			else
 				index = model->modelIndexOfAspect(aspects.at(row));
 
 			if (expandedItem)
 				expanded.push_back(index);
 			else if (selectedItem)
 				selected.push_back(index);
 			else if (currentItem)
 				currentIndex = index;
 			else if (viewItem) {
 				AbstractPart* part = dynamic_cast<AbstractPart*>(aspects.at(row));
 				if (!part)
 					continue; //TODO: add error/warning message here?
 
 				emit currentAspectChanged(part);
 
 				str = attribs.value("state").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.subs("state").toString());
 				else {
 					part->view()->setWindowState(Qt::WindowStates(str.toInt()));
 					part->mdiSubWindow()->setWindowState(Qt::WindowStates(str.toInt()));
 				}
 
 				if (str != "0")
 					continue; //no geometry settings required for maximized/minimized windows
 
 				QRect geometry;
 				str = attribs.value("x").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.subs("x").toString());
 				else
 					geometry.setX(str.toInt());
 
 				str = attribs.value("y").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.subs("y").toString());
 				else
 					geometry.setY(str.toInt());
 
 				str = attribs.value("width").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.subs("width").toString());
 				else
 					geometry.setWidth(str.toInt());
 
 				str = attribs.value("height").toString();
 				if(str.isEmpty())
 					reader->raiseWarning(attributeWarning.subs("height").toString());
 				else
 					geometry.setHeight(str.toInt());
 
 				part->mdiSubWindow()->setGeometry(geometry);
 			}
 		}
 	}
 
 	for (const auto& index : expanded) {
 		m_treeView->setExpanded(index, true);
 		collapseParents(index, expanded);//collapse all parent indices if they are not expanded
 	}
 
 	for (const auto& index : selected)
 		m_treeView->selectionModel()->select(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
 
 	m_treeView->setCurrentIndex(currentIndex);
 	m_treeView->scrollTo(currentIndex);
 
 	//when setting the current index above it gets expanded, collapse all parent indices if they are were not expanded when saved
 	collapseParents(currentIndex, expanded);
 
 	return true;
 }
 
 void ProjectExplorer::collapseParents(const QModelIndex& index, const QList<QModelIndex>& expanded) {
 	//root index doesn't have any parents - this case is not caught by the second if-statement below
 	if (index.column()==0 && index.row()==0)
 		return;
 
 	const QModelIndex parent = index.parent();
 	if (parent == QModelIndex())
 		return;
 
 	if (expanded.indexOf(parent) == -1)
 		m_treeView->collapse(parent);
 }
diff --git a/src/commonfrontend/matrix/MatrixView.cpp b/src/commonfrontend/matrix/MatrixView.cpp
index 5990abbf9..695fbc28a 100644
--- a/src/commonfrontend/matrix/MatrixView.cpp
+++ b/src/commonfrontend/matrix/MatrixView.cpp
@@ -1,1482 +1,1482 @@
 /***************************************************************************
     File                 : MatrixView.cpp
     Project              : LabPlot
     Description          : View class for Matrix
     --------------------------------------------------------------------
     Copyright            : (C) 2008-2009 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2015 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2017 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 "commonfrontend/matrix/MatrixView.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/matrix/MatrixModel.h"
 #include "backend/matrix/matrixcommands.h"
 #include "backend/lib/macros.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/column/ColumnPrivate.h"
 
 #include "kdefrontend/matrix/MatrixFunctionDialog.h"
 #include "kdefrontend/spreadsheet/StatisticsDialog.h"
 
 #include <QAction>
 #include <QStackedWidget>
 #include <QTableView>
 #include <QKeyEvent>
 #include <QShortcut>
 #include <QMenu>
 #include <QPainter>
 #include <QPrinter>
 #include <QScrollArea>
 #include <QInputDialog>
 #include <QClipboard>
 #include <QMimeData>
 #include <QTextStream>
 #include <QThreadPool>
 #include <QMutex>
 #include <QProcess>
 #include <QHeaderView>
 
 #include <KLocalizedString>
 #include <QIcon>
 
 #include <cfloat>
 #include <cmath>
 
 MatrixView::MatrixView(Matrix* matrix) : QWidget(),
 	m_stackedWidget(new QStackedWidget(this)),
 	m_tableView(new QTableView(this)),
 	m_imageLabel(new QLabel(this)),
 	m_matrix(matrix),
 	m_model(new MatrixModel(matrix)),
 	m_imageIsDirty(true) {
 
 	init();
 
 	//resize the view to show a 10x10 region of the matrix.
 	//no need to resize the view when the project is being opened,
 	//all views will be resized to the stored values at the end
 	if (!m_matrix->isLoading()) {
 		int w = m_tableView->horizontalHeader()->sectionSize(0)*10 + m_tableView->verticalHeader()->width();
 		int h = m_tableView->verticalHeader()->sectionSize(0)*10 + m_tableView->horizontalHeader()->height();
 		resize(w+50, h+50);
 	}
 }
 
 MatrixView::~MatrixView() {
 	delete m_model;
 }
 
 MatrixModel* MatrixView::model() const {
 	return m_model;
 }
 
 void MatrixView::init() {
 	initActions();
 	connectActions();
 	initMenus();
 
 	QHBoxLayout* layout = new QHBoxLayout(this);
 	layout->setContentsMargins(0,0,0,0);
 	setSizePolicy(QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding));
 	setFocusPolicy(Qt::StrongFocus);
 	setFocus();
 	installEventFilter(this);
 
 	layout->addWidget(m_stackedWidget);
 
 	//table data view
 	m_tableView->setModel(m_model);
 	m_stackedWidget->addWidget(m_tableView);
 
 	//horizontal header
 	QHeaderView* h_header = m_tableView->horizontalHeader();
 	h_header->setSectionsMovable(false);
 	h_header->installEventFilter(this);
 
 	//vertical header
 	QHeaderView* v_header = m_tableView->verticalHeader();
 	v_header->setSectionsMovable(false);
 	v_header->installEventFilter(this);
 
 	//set the header sizes to the (potentially user customized) sizes stored in Matrix
 	adjustHeaders();
 
 	//image view
 	QScrollArea* area = new QScrollArea(this);
 	m_stackedWidget->addWidget(area);
 	area->setWidget(m_imageLabel);
 
 	//SLOTs
 	connect(m_matrix, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)));
 	connect(m_model, SIGNAL(changed()), this, SLOT(matrixDataChanged()));
 
 	//keyboard shortcuts
 	QShortcut* sel_all = new QShortcut(QKeySequence(tr("Ctrl+A", "Matrix: select all")), m_tableView);
 	connect(sel_all, SIGNAL(activated()), m_tableView, SLOT(selectAll()));
 
 	//TODO: add shortcuts for copy&paste,
 	//for a single shortcut we need to descriminate between copy&paste for columns, rows or selected cells.
 }
 
 void MatrixView::initActions() {
 	// selection related actions
 	action_cut_selection = new QAction(QIcon::fromTheme("edit-cut"), i18n("Cu&t"), this);
 	action_copy_selection = new QAction(QIcon::fromTheme("edit-copy"), i18n("&Copy"), this);
 	action_paste_into_selection = new QAction(QIcon::fromTheme("edit-paste"), i18n("Past&e"), this);
 	action_clear_selection = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clea&r Selection"), this);
 	action_select_all = new QAction(QIcon::fromTheme("edit-select-all"), i18n("Select All"), this);
 
 	// matrix related actions
 	QActionGroup* viewActionGroup = new QActionGroup(this);
 	viewActionGroup->setExclusive(true);
 	action_data_view = new QAction(QIcon::fromTheme("labplot-matrix"), i18n("Data"), viewActionGroup);
 	action_data_view->setCheckable(true);
 	action_data_view->setChecked(true);
 	action_image_view = new QAction(QIcon::fromTheme("image-x-generic"), i18n("Image"), viewActionGroup);
 	action_image_view->setCheckable(true);
 	connect(viewActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(switchView(QAction*)));
 
 	action_fill_function = new QAction(QIcon::fromTheme(""), i18n("Function Values"), this);
 	action_fill_const = new QAction(QIcon::fromTheme(""), i18n("Const Values"), this);
 	action_clear_matrix = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clear Matrix"), this);
 	action_go_to_cell = new QAction(QIcon::fromTheme("go-jump"), i18n("&Go to Cell"), this);
 
 	action_transpose = new QAction(i18n("&Transpose"), this);
 	action_mirror_horizontally = new QAction(QIcon::fromTheme("object-flip-horizontal"), i18n("Mirror &Horizontally"), this);
 	action_mirror_vertically = new QAction(QIcon::fromTheme("object-flip-vertical"), i18n("Mirror &Vertically"), this);
 // 	action_duplicate = new QAction(i18nc("duplicate matrix", "&Duplicate"), this);
 	//TODO
 	//icon
 	QActionGroup* headerFormatActionGroup = new QActionGroup(this);
 	headerFormatActionGroup->setExclusive(true);
 	action_header_format_1= new QAction(i18n("Rows and Columns"), headerFormatActionGroup);
 	action_header_format_1->setCheckable(true);
 	action_header_format_2= new QAction(i18n("xy-Values"), headerFormatActionGroup);
 	action_header_format_2->setCheckable(true);
 	action_header_format_3= new QAction(i18n("Rows, Columns and xy-Values"), headerFormatActionGroup);
 	action_header_format_3->setCheckable(true);
 	connect(headerFormatActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(headerFormatChanged(QAction*)));
 
 	// column related actions
 	action_add_columns = new QAction(QIcon::fromTheme("edit-table-insert-column-right"), i18n("&Add Columns"), this);
 	action_insert_columns = new QAction(QIcon::fromTheme("edit-table-insert-column-left"), i18n("&Insert Empty Columns"), this);
 	action_remove_columns = new QAction(QIcon::fromTheme("edit-table-delete-column"), i18n("Remo&ve Columns"), this);
 	action_clear_columns = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clea&r Columns"), this);
 	action_statistics_columns = new QAction(QIcon::fromTheme("view-statistics"), i18n("Statisti&cs"), this);
 
 	// row related actions
 	action_add_rows = new QAction(QIcon::fromTheme("edit-table-insert-row-above"), i18n("&Add Rows"), this);
 	action_insert_rows = new QAction(QIcon::fromTheme("edit-table-insert-row-above") ,i18n("&Insert Empty Rows"), this);
 	action_remove_rows = new QAction(QIcon::fromTheme("edit-table-delete-row"), i18n("Remo&ve Rows"), this);
 	action_clear_rows = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clea&r Rows"), this);
 	action_statistics_rows = new QAction(QIcon::fromTheme("view-statistics"), i18n("Statisti&cs"), this);
 }
 
 void MatrixView::connectActions() {
 	// selection related actions
 	connect(action_cut_selection, SIGNAL(triggered()), this, SLOT(cutSelection()));
 	connect(action_copy_selection, SIGNAL(triggered()), this, SLOT(copySelection()));
 	connect(action_paste_into_selection, SIGNAL(triggered()), this, SLOT(pasteIntoSelection()));
 	connect(action_clear_selection, SIGNAL(triggered()), this, SLOT(clearSelectedCells()));
 	connect(action_select_all, SIGNAL(triggered()), m_tableView, SLOT(selectAll()));
 
 	// matrix related actions
 	connect(action_fill_function, SIGNAL(triggered()), this, SLOT(fillWithFunctionValues()));
 	connect(action_fill_const, SIGNAL(triggered()), this, SLOT(fillWithConstValues()));
 
 	connect(action_go_to_cell, SIGNAL(triggered()), this, SLOT(goToCell()));
 	//connect(action_duplicate, SIGNAL(triggered()), this, SLOT(duplicate()));
 	connect(action_clear_matrix, SIGNAL(triggered()), m_matrix, SLOT(clear()));
 	connect(action_transpose, SIGNAL(triggered()), m_matrix, SLOT(transpose()));
 	connect(action_mirror_horizontally, SIGNAL(triggered()), m_matrix, SLOT(mirrorHorizontally()));
 	connect(action_mirror_vertically, SIGNAL(triggered()), m_matrix, SLOT(mirrorVertically()));
 
 	// column related actions
 	connect(action_add_columns, SIGNAL(triggered()), this, SLOT(addColumns()));
 	connect(action_insert_columns, SIGNAL(triggered()), this, SLOT(insertEmptyColumns()));
 	connect(action_remove_columns, SIGNAL(triggered()), this, SLOT(removeSelectedColumns()));
 	connect(action_clear_columns, SIGNAL(triggered()), this, SLOT(clearSelectedColumns()));
 	connect(action_statistics_columns, SIGNAL(triggered()), this, SLOT(showColumnStatistics()));
 
 	// row related actions
 	connect(action_add_rows, SIGNAL(triggered()), this, SLOT(addRows()));
 	connect(action_insert_rows, SIGNAL(triggered()), this, SLOT(insertEmptyRows()));
 	connect(action_remove_rows, SIGNAL(triggered()), this, SLOT(removeSelectedRows()));
 	connect(action_clear_rows, SIGNAL(triggered()), this, SLOT(clearSelectedRows()));
 	connect(action_statistics_rows, SIGNAL(triggered()), this, SLOT(showRowStatistics()));
 }
 
 void MatrixView::initMenus() {
 	//selection menu
 	m_selectionMenu = new QMenu(i18n("Selection"), this);
 	m_selectionMenu->addAction(action_cut_selection);
 	m_selectionMenu->addAction(action_copy_selection);
 	m_selectionMenu->addAction(action_paste_into_selection);
 	m_selectionMenu->addAction(action_clear_selection);
 
 	//column menu
 	m_columnMenu = new QMenu(this);
 	m_columnMenu->addAction(action_insert_columns);
 	m_columnMenu->addAction(action_remove_columns);
 	m_columnMenu->addAction(action_clear_columns);
 	m_columnMenu->addAction(action_statistics_columns);
 
 	//row menu
 	m_rowMenu = new QMenu(this);
 	m_rowMenu->addAction(action_insert_rows);
 	m_rowMenu->addAction(action_remove_rows);
 	m_rowMenu->addAction(action_clear_rows);
 	m_rowMenu->addAction(action_statistics_rows);
 
 	//matrix menu
 	m_matrixMenu = new QMenu(this);
 
 	m_matrixMenu->addMenu(m_selectionMenu);
 	m_matrixMenu->addSeparator();
 
 	QMenu* submenu = new QMenu(i18n("Generate Data"), this);
 	submenu->addAction(action_fill_const);
 	submenu->addAction(action_fill_function);
 	m_matrixMenu->addMenu(submenu);
 	m_matrixMenu->addSeparator();
 
 	submenu = new QMenu(i18n("View"), this);
 	submenu->addAction(action_data_view);
 	submenu->addAction(action_image_view);
 	m_matrixMenu->addMenu(submenu);
 	m_matrixMenu->addSeparator();
 
 	m_matrixMenu->addAction(action_select_all);
 	m_matrixMenu->addAction(action_clear_matrix);
 	m_matrixMenu->addSeparator();
 
 	m_matrixMenu->addAction(action_transpose);
 	m_matrixMenu->addAction(action_mirror_horizontally);
 	m_matrixMenu->addAction(action_mirror_vertically);
 	m_matrixMenu->addSeparator();
 
 	m_headerFormatMenu = new QMenu(i18n("Header Format"), this);
 	m_headerFormatMenu->addAction(action_header_format_1);
 	m_headerFormatMenu->addAction(action_header_format_2);
 	m_headerFormatMenu->addAction(action_header_format_3);
 
 	m_matrixMenu->addMenu(m_headerFormatMenu);
 	m_matrixMenu->addSeparator();
 	m_matrixMenu->addAction(action_go_to_cell);
 }
 
 /*!
  * Populates the menu \c menu with the spreadsheet and spreadsheet view relevant actions.
  * The menu is used
  *   - as the context menu in MatrixView
  *   - as the "matrix menu" in the main menu-bar (called form MainWin)
  *   - as a part of the matrix context menu in project explorer
  */
 void MatrixView::createContextMenu(QMenu* menu) const {
 	Q_ASSERT(menu);
 
 	QAction* firstAction = nullptr;
 	// 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->insertMenu(firstAction, m_selectionMenu);
 	menu->insertSeparator(firstAction);
 
 	QMenu* submenu = new QMenu(i18n("Generate Data"), const_cast<MatrixView*>(this));
 	submenu->addAction(action_fill_const);
 	submenu->addAction(action_fill_function);
 	menu->insertMenu(firstAction, submenu);
 	menu->insertSeparator(firstAction);
 
 	submenu = new QMenu(i18n("View"), const_cast<MatrixView*>(this));
 	submenu->addAction(action_data_view);
 	submenu->addAction(action_image_view);
 	menu->insertMenu(firstAction, submenu);
 	menu->insertSeparator(firstAction);
 
 	menu->insertAction(firstAction, action_select_all);
 	menu->insertAction(firstAction, action_clear_matrix);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, action_transpose);
 	menu->insertAction(firstAction, action_mirror_horizontally);
 	menu->insertAction(firstAction, action_mirror_vertically);
 	menu->insertSeparator(firstAction);
 // 	menu->insertAction(firstAction, action_duplicate);
 	menu->insertMenu(firstAction, m_headerFormatMenu);
 
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, action_go_to_cell);
 	menu->insertSeparator(firstAction);
 }
 
 /*!
 	set the row and column size to the saved sizes.
  */
 void MatrixView::adjustHeaders() {
 	QHeaderView* h_header = m_tableView->horizontalHeader();
 	QHeaderView* v_header = m_tableView->verticalHeader();
 
 	disconnect(v_header, &QHeaderView::sectionResized, this, &MatrixView::handleVerticalSectionResized);
 	disconnect(h_header, &QHeaderView::sectionResized, this, &MatrixView::handleHorizontalSectionResized);
 
 	//resize columns to the saved sizes or to fit the contents if the widht is 0
 	int cols = m_matrix->columnCount();
 	for (int i=0; i<cols; i++) {
 		if (m_matrix->columnWidth(i) == 0)
 			m_tableView->resizeColumnToContents(i);
 		else
 			m_tableView->setColumnWidth(i, m_matrix->columnWidth(i));
 	}
 
 	//resize rows to the saved sizes or to fit the contents if the height is 0
 	int rows = m_matrix->rowCount();
 	for (int i=0; i<rows; i++) {
 		if (m_matrix->rowHeight(i) == 0)
 			m_tableView->resizeRowToContents(i);
 		else
 			m_tableView->setRowHeight(i, m_matrix->rowHeight(i));
 	}
 
 	connect(v_header, SIGNAL(sectionResized(int,int,int)), this, SLOT(handleVerticalSectionResized(int,int,int)));
 	connect(h_header, SIGNAL(sectionResized(int,int,int)), this, SLOT(handleHorizontalSectionResized(int,int,int)));
 }
 
 /*!
 	Resizes the headers/columns to fit the new content. Called on changes of the header format in Matrix.
 */
 void MatrixView::resizeHeaders() {
 	m_tableView->resizeColumnsToContents();
 	m_tableView->resizeRowsToContents();
 
 	if (m_matrix->headerFormat() == Matrix::HeaderRowsColumns)
 		action_header_format_1->setChecked(true);
 	else if (m_matrix->headerFormat() == Matrix::HeaderValues)
 		action_header_format_2->setChecked(true);
 	else
 		action_header_format_3->setChecked(true);
 }
 
 /*!
 	Returns how many columns are selected.
 	If full is true, this function only returns the number of fully selected columns.
 */
 int MatrixView::selectedColumnCount(bool full) const {
 	int count = 0;
 	int cols = m_matrix->columnCount();
 	for (int i=0; i<cols; i++)
 		if (isColumnSelected(i, full)) count++;
 	return count;
 }
 
 /*!
 	Returns true if column 'col' is selected; otherwise false.
 	If full is true, this function only returns true if the whole column is selected.
 */
 bool MatrixView::isColumnSelected(int col, bool full) const {
 	if (full)
 		return m_tableView->selectionModel()->isColumnSelected(col, QModelIndex());
 	else
 		return m_tableView->selectionModel()->columnIntersectsSelection(col, QModelIndex());
 }
 
 /*!
 	Return how many rows are (at least partly) selected
 	If full is true, this function only returns the number of fully selected rows.
 */
 int MatrixView::selectedRowCount(bool full) const {
 	int count = 0;
 	int rows = m_matrix->rowCount();
 	for (int i=0; i < rows; i++)
 		if (isRowSelected(i, full)) count++;
 	return count;
 }
 
 /*!
 	Returns true if row \c row is selected; otherwise false
 	If full is true, this function only returns true if the whole row is selected.
 */
 bool MatrixView::isRowSelected(int row, bool full) const {
 	if (full)
 		return m_tableView->selectionModel()->isRowSelected(row, QModelIndex());
 	else
 		return m_tableView->selectionModel()->rowIntersectsSelection(row, QModelIndex());
 }
 
 /*!
 	Return the index of the first selected column.
 	If full is true, this function only looks for fully selected columns.
 */
 int MatrixView::firstSelectedColumn(bool full) const {
 	int cols = m_matrix->columnCount();
 	for (int i=0; i<cols; i++) {
 		if (isColumnSelected(i, full))
 			return i;
 	}
 	return -1;
 }
 
 /*!
 	Return the index of the last selected column
 	If full is true, this function only looks for fully selected columns.
 */
 int MatrixView::lastSelectedColumn(bool full) const {
 	int cols = m_matrix->columnCount();
 	for (int i=cols-1; i >= 0; i--)
 		if (isColumnSelected(i, full)) return i;
 
 	return -2;
 }
 
 /*!
 	Return the index of the first selected row.
 	If full is true, this function only looks for fully selected rows.
 */
 int MatrixView::firstSelectedRow(bool full) const {
 	int rows = m_matrix->rowCount();
 	for (int i=0; i < rows; i++) 	{
 		if (isRowSelected(i, full))
 			return i;
 	}
 	return -1;
 }
 
 /*!
 	Return the index of the last selected row
 	If full is true, this function only looks for fully selected rows.
 */
 int MatrixView::lastSelectedRow(bool full) const {
 	int rows = m_matrix->rowCount();
 	for (int i=rows-1; i >= 0; i--)
 		if (isRowSelected(i, full)) return i;
 
 	return -2;
 }
 
 bool MatrixView::isCellSelected(int row, int col) const {
 	if (row < 0 || col < 0 || row >= m_matrix->rowCount() || col >= m_matrix->columnCount()) return false;
 
 	return m_tableView->selectionModel()->isSelected(m_model->index(row, col));
 }
 
 void MatrixView::setCellSelected(int row, int col) {
 	m_tableView->selectionModel()->select(m_model->index(row, col), QItemSelectionModel::Select);
 }
 
 void MatrixView::setCellsSelected(int first_row, int first_col, int last_row, int last_col) {
 	QModelIndex top_left = m_model->index(first_row, first_col);
 	QModelIndex bottom_right = m_model->index(last_row, last_col);
 	m_tableView->selectionModel()->select(QItemSelection(top_left, bottom_right), QItemSelectionModel::SelectCurrent);
 }
 
 /*!
 	Determine the current cell (-1 if no cell is designated as the current)
 */
 void MatrixView::getCurrentCell(int* row, int* col) const {
 	QModelIndex index = m_tableView->selectionModel()->currentIndex();
 	if (index.isValid()) {
 		*row = index.row();
 		*col = index.column();
 	} else {
 		*row = -1;
 		*col = -1;
 	}
 }
 
 bool MatrixView::eventFilter(QObject * watched, QEvent * event) {
 	if (event->type() == QEvent::ContextMenu) {
 		QContextMenuEvent* cm_event = static_cast<QContextMenuEvent*>(event);
 		QPoint global_pos = cm_event->globalPos();
 		if (watched == m_tableView->verticalHeader())
 			m_rowMenu->exec(global_pos);
 		else if (watched == m_tableView->horizontalHeader())
 			m_columnMenu->exec(global_pos);
 		else if (watched == this)
 			m_matrixMenu->exec(global_pos);
 		else
 			return QWidget::eventFilter(watched, event);
 		return true;
 	} else
 		return QWidget::eventFilter(watched, event);
 }
 
 void MatrixView::keyPressEvent(QKeyEvent* event) {
 	if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter)
 		advanceCell();
 }
 
 //##############################################################################
 //####################################  SLOTs   ################################
 //##############################################################################
 /*!
 	Advance current cell after [Return] or [Enter] was pressed
 */
 void MatrixView::advanceCell() {
 	QModelIndex idx = m_tableView->currentIndex();
 	if (idx.row()+1 < m_matrix->rowCount())
 		m_tableView->setCurrentIndex(idx.sibling(idx.row()+1, idx.column()));
 }
 
 void MatrixView::goToCell() {
 	bool ok;
 
 	int col = QInputDialog::getInt(nullptr, i18n("Go to Cell"), i18n("Enter column"), 1, 1, m_matrix->columnCount(), 1, &ok);
 	if (!ok) return;
 
 	int row = QInputDialog::getInt(nullptr, i18n("Go to Cell"), i18n("Enter row"), 1, 1, m_matrix->rowCount(), 1, &ok);
 	if (!ok) return;
 
 	goToCell(row-1, col-1);
 }
 
 void MatrixView::goToCell(int row, int col) {
 	QModelIndex index = m_model->index(row, col);
 	m_tableView->scrollTo(index);
 	m_tableView->setCurrentIndex(index);
 }
 
 void MatrixView::handleHorizontalSectionResized(int logicalIndex, int oldSize, int newSize) {
 	Q_UNUSED(oldSize)
 	m_matrix->setColumnWidth(logicalIndex, newSize);
 }
 
 void MatrixView::handleVerticalSectionResized(int logicalIndex, int oldSize, int newSize) {
 	Q_UNUSED(oldSize)
 	m_matrix->setRowHeight(logicalIndex, newSize);
 }
 
 void MatrixView::fillWithFunctionValues() {
 	MatrixFunctionDialog* dlg = new MatrixFunctionDialog(m_matrix);
 	dlg->exec();
 }
 
 void MatrixView::fillWithConstValues() {
 	bool ok = false;
 	double value = QInputDialog::getDouble(this, i18n("Fill the matrix with constant value"),
 	                                       i18n("Value"), 0, -2147483647, 2147483647, 6, &ok);
 	if (ok) {
 		WAIT_CURSOR;
 		QVector<QVector<double>>* newData = static_cast<QVector<QVector<double>>*>(m_matrix->data());
 		for (int col = 0; col < m_matrix->columnCount(); ++col) {
 			for (int row = 0; row < m_matrix->rowCount(); ++row)
 				(newData->operator[](col))[row] = value;
 		}
 		m_matrix->setData(newData);
 		RESET_CURSOR;
 	}
 }
 
 //############################ selection related slots #########################
 void MatrixView::cutSelection() {
 	if (firstSelectedRow() < 0) return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: cut selected cell(s)", m_matrix->name()));
 	copySelection();
 	clearSelectedCells();
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::copySelection() {
 	int first_col = firstSelectedColumn(false);
 	if (first_col == -1) return;
 	int last_col = lastSelectedColumn(false);
 	if (last_col == -2) return;
 	int first_row = firstSelectedRow(false);
 	if (first_row == -1)	return;
 	int last_row = lastSelectedRow(false);
 	if (last_row == -2) return;
 	int cols = last_col - first_col +1;
 	int rows = last_row - first_row +1;
 
 	WAIT_CURSOR;
 	QString output_str;
 
 	for (int r=0; r < rows; r++) 	{
 		for (int c=0; c < cols; c++) {
 			//TODO: mode
 			if (isCellSelected(first_row + r, first_col + c))
 				output_str += QLocale().toString(m_matrix->cell<double>(first_row + r, first_col + c),
 				                                 m_matrix->numericFormat(), 16); // copy with max. precision
 			if (c < cols-1)
 				output_str += '\t';
 		}
 		if (r < rows-1)
 			output_str += '\n';
 	}
 	QApplication::clipboard()->setText(output_str);
 	RESET_CURSOR;
 }
 
 void MatrixView::pasteIntoSelection() {
 	if (m_matrix->columnCount() < 1 || m_matrix->rowCount() < 1) return;
 
 	const QMimeData* mime_data = QApplication::clipboard()->mimeData();
 	if (!mime_data->hasFormat("text/plain"))
 		return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: paste from clipboard", m_matrix->name()));
 
 	int first_col = firstSelectedColumn(false);
 	int last_col = lastSelectedColumn(false);
 	int first_row = firstSelectedRow(false);
 	int last_row = lastSelectedRow(false);
 	int input_row_count = 0;
 	int input_col_count = 0;
 	int rows, cols;
 
 	QString input_str = QString(mime_data->data("text/plain"));
 	QList< QStringList > cell_texts;
 	QStringList input_rows(input_str.split('\n'));
 	input_row_count = input_rows.count();
 	input_col_count = 0;
 	for (int i=0; i < input_row_count; i++) {
 		cell_texts.append(input_rows.at(i).split('\t'));
 		if (cell_texts.at(i).count() > input_col_count) input_col_count = cell_texts.at(i).count();
 	}
 
 	// if the is no selection or only one cell selected, the
 	// selection will be expanded to the needed size from the current cell
 	if ( (first_col == -1 || first_row == -1) ||
 	        (last_row == first_row && last_col == first_col) ) {
 		int current_row, current_col;
 		getCurrentCell(&current_row, &current_col);
 		if (current_row == -1) current_row = 0;
 		if (current_col == -1) current_col = 0;
 		setCellSelected(current_row, current_col);
 		first_col = current_col;
 		first_row = current_row;
 		last_row = first_row + input_row_count -1;
 		last_col = first_col + input_col_count -1;
 		// resize the matrix if necessary
 		if (last_col >= m_matrix->columnCount())
 			m_matrix->appendColumns(last_col+1-m_matrix->columnCount());
 		if (last_row >= m_matrix->rowCount())
 			m_matrix->appendRows(last_row+1-m_matrix->rowCount());
 		// select the rectangle to be pasted in
 		setCellsSelected(first_row, first_col, last_row, last_col);
 	}
 
 	rows = last_row - first_row + 1;
 	cols = last_col - first_col + 1;
 	for (int r=0; r<rows && r<input_row_count; r++) {
 		for (int c=0; c<cols && c<input_col_count; c++) {
 			if (isCellSelected(first_row + r, first_col + c) && (c < cell_texts.at(r).count()) )
 				m_matrix->setCell(first_row + r, first_col + c, cell_texts.at(r).at(c).toDouble());
 		}
 	}
 
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::clearSelectedCells() {
 	int first_row = firstSelectedRow();
 	if (first_row<0)
 		return;
 
 	int first_col = firstSelectedColumn();
 	if (first_col<0)
 		return;
 
 	int last_row = lastSelectedRow();
 	int last_col = lastSelectedColumn();
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: clear selected cell(s)", m_matrix->name()));
 	for (int i=first_row; i <= last_row; i++) {
 		for (int j=first_col; j <= last_col; j++) {
 			if (isCellSelected(i, j))
 				m_matrix->clearCell(i, j);
 		}
 	}
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 
 class UpdateImageTask : public QRunnable {
 public:
 	UpdateImageTask(int start, int end, QImage& image, const void* data, double scaleFactor, double min) : m_image(image), m_data(data) {
 		m_start = start;
 		m_end = end;
 		m_scaleFactor = scaleFactor;
 		m_min = min;
 	};
 
 	void run() override {
 		for (int row = m_start; row < m_end; ++row) {
 			m_mutex.lock();
 			QRgb* line = reinterpret_cast<QRgb*>(m_image.scanLine(row));
 			m_mutex.unlock();
 			for (int col = 0; col < m_image.width(); ++col) {
 				const int gray = (static_cast<const QVector<QVector<double>>*>(m_data)->at(col).at(row)-m_min)*m_scaleFactor;
 				line[col] = qRgb(gray, gray, gray);
 			}
 		}
 	}
 
 private:
 	QMutex m_mutex;
 	int m_start;
 	int m_end;
 	QImage& m_image;
 	const void* m_data;
 	double m_scaleFactor;
 	double m_min;
 };
 
 void MatrixView::updateImage() {
 	WAIT_CURSOR;
 	m_image = QImage(m_matrix->columnCount(), m_matrix->rowCount(), QImage::Format_ARGB32);
 
 	//find min/max value
 	double dmax = -DBL_MAX, dmin = DBL_MAX;
 	const QVector<QVector<double>>* data = static_cast<QVector<QVector<double>>*>(m_matrix->data());
 	const int width = m_matrix->columnCount();
 	const int height = m_matrix->rowCount();
 	for (int col = 0; col < width; ++col) {
 		for (int row = 0; row < height; ++row) {
 			const double value = (data->operator[](col))[row];
 			if (dmax < value) dmax = value;
 			if (dmin > value) dmin = value;
 		}
 	}
 
 	//update the image
 	const double scaleFactor = 255.0/(dmax-dmin);
 	QThreadPool* pool = QThreadPool::globalInstance();
 	int range = ceil(double(m_image.height())/pool->maxThreadCount());
 	for (int i = 0; i < pool->maxThreadCount(); ++i) {
 		const int start = i*range;
 		int end = (i+1)*range;
 		if (end>m_image.height()) end = m_image.height();
 		UpdateImageTask* task = new UpdateImageTask(start, end, m_image, data, scaleFactor, dmin);
 		pool->start(task);
 	}
 	pool->waitForDone();
 
 	m_imageLabel->resize(width, height);
 	m_imageLabel->setPixmap(QPixmap::fromImage(m_image));
 	m_imageIsDirty = false;
 	RESET_CURSOR;
 }
 
 //############################# matrix related slots ###########################
 void MatrixView::switchView(QAction* action) {
 	if (action == action_data_view)
 		m_stackedWidget->setCurrentIndex(0);
 	else {
 		if (m_imageIsDirty)
 			this->updateImage();
 
 		m_stackedWidget->setCurrentIndex(1);
 	}
 }
 
 void MatrixView::matrixDataChanged() {
 	m_imageIsDirty = true;
 	if (m_stackedWidget->currentIndex() == 1)
 		this->updateImage();
 }
 
 void MatrixView::headerFormatChanged(QAction* action) {
 	if (action == action_header_format_1)
 		m_matrix->setHeaderFormat(Matrix::HeaderRowsColumns);
 	else if (action == action_header_format_2)
 		m_matrix->setHeaderFormat(Matrix::HeaderValues);
 	else
 		m_matrix->setHeaderFormat(Matrix::HeaderRowsColumnsValues);
 }
 
 //############################# column related slots ###########################
 /*!
   Append as many columns as are selected.
 */
 void MatrixView::addColumns() {
 	m_matrix->appendColumns(selectedColumnCount(false));
 }
 
 void MatrixView::insertEmptyColumns() {
 	int first = firstSelectedColumn();
 	int last = lastSelectedColumn();
 	if (first < 0) return;
 	int count, current = first;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: insert empty column(s)", m_matrix->name()));
 	while (current <= last) {
 		current = first+1;
 		while (current <= last && isColumnSelected(current)) current++;
 		count = current-first;
 		m_matrix->insertColumns(first, count);
 		current += count;
 		last += count;
 		while (current <= last && isColumnSelected(current)) current++;
 		first = current;
 	}
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::removeSelectedColumns() {
 	int first = firstSelectedColumn();
 	int last = lastSelectedColumn();
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: remove selected column(s)", m_matrix->name()));
 	for (int i=last; i >= first; i--)
 		if (isColumnSelected(i, false)) m_matrix->removeColumns(i, 1);
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::clearSelectedColumns() {
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: clear selected column(s)", m_matrix->name()));
 	for (int i=0; i < m_matrix->columnCount(); i++) {
 		if (isColumnSelected(i, false))
 			m_matrix->clearColumn(i);
 	}
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 //############################## rows related slots ############################
 /*!
   Append as many rows as are selected.
 */
 void MatrixView::addRows() {
 	m_matrix->appendRows(selectedRowCount(false));
 }
 
 void MatrixView::insertEmptyRows() {
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	int count, current = first;
 
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: insert empty rows(s)", m_matrix->name()));
 	while (current <= last) {
 		current = first+1;
 		while (current <= last && isRowSelected(current)) current++;
 		count = current-first;
 		m_matrix->insertRows(first, count);
 		current += count;
 		last += count;
 		while (current <= last && !isRowSelected(current)) current++;
 		first = current;
 	}
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::removeSelectedRows() {
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: remove selected rows(s)", m_matrix->name()));
 	for (int i=last; i >= first; i--)
 		if (isRowSelected(i, false)) m_matrix->removeRows(i, 1);
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 void MatrixView::clearSelectedRows() {
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_matrix->beginMacro(i18n("%1: clear selected rows(s)", m_matrix->name()));
 	for (int i=first; i <= last; i++) {
 		if (isRowSelected(i))
 			m_matrix->clearRow(i);
 	}
 	m_matrix->endMacro();
 	RESET_CURSOR;
 }
 
 /*!
   prints the complete matrix to \c printer.
  */
 
 void MatrixView::print(QPrinter* printer) const {
 	WAIT_CURSOR;
 	QPainter painter (printer);
 
 	const int dpiy = printer->logicalDpiY();
 	const int margin = (int) ( (1/2.54)*dpiy ); // 1 cm margins
 
 	QHeaderView *hHeader = m_tableView->horizontalHeader();
 	QHeaderView *vHeader = m_tableView->verticalHeader();
 	QVector<QVector<double>>* data = static_cast<QVector<QVector<double>>*>(m_matrix->data());
 
 	const int rows = m_matrix->rowCount();
 	const int cols = m_matrix->columnCount();
 	int height = margin;
 	const int vertHeaderWidth = vHeader->width();
 	int right = margin + vertHeaderWidth;
 
 	int columnsPerTable = 0;
 	int headerStringWidth = 0;
 	int firstRowStringWidth = vertHeaderWidth;
 	bool tablesNeeded = false;
 	QVector<int> firstRowCeilSizes;
 	firstRowCeilSizes.reserve(data[0].size());
 	firstRowCeilSizes.resize(data[0].size());
 	QRect br;
 
 	for (int i = 0; i < data->size(); ++i) {
 		br = painter.boundingRect(br, Qt::AlignCenter,QString::number(data->at(i)[0]) + '\t');
 		firstRowCeilSizes[i] = br.width() > m_tableView->columnWidth(i) ?
 		                       br.width() : m_tableView->columnWidth(i);
 	}
 	for (int col = 0; col < cols; ++col) {
 		headerStringWidth += m_tableView->columnWidth(col);
 		br = painter.boundingRect(br, Qt::AlignCenter,QString::number(data->at(col)[0]) + '\t');
 		firstRowStringWidth += br.width();
 		if ((headerStringWidth >= printer->pageRect().width() -2*margin) ||
 		        (firstRowStringWidth >= printer->pageRect().width() - 2*margin)) {
 			tablesNeeded = true;
 			break;
 		}
 		columnsPerTable++;
 	}
 
 	int tablesCount = (columnsPerTable != 0) ? cols/columnsPerTable : 0;
 	const int remainingColumns = (columnsPerTable != 0) ? cols % columnsPerTable : cols;
 
 	if (!tablesNeeded) {
 		tablesCount = 1;
 		columnsPerTable = cols;
 	}
 	if (remainingColumns > 0)
 		tablesCount++;
 	for (int table = 0; table < tablesCount; ++table) {
 		right = margin + vertHeaderWidth;
 		//Paint the horizontal header first
 		painter.setFont(hHeader->font());
 		QString headerString = m_tableView->model()->headerData(0, Qt::Horizontal).toString();
 		QRect br;
 		br = painter.boundingRect(br, Qt::AlignCenter, headerString);
 		QRect tr(br);
 		if (table != 0)
 			height += tr.height();
 		painter.drawLine(right, height, right, height+br.height());
 
 		int w;
 		int i = table * columnsPerTable;
 		int toI = table * columnsPerTable + columnsPerTable;
 		if ((remainingColumns > 0) && (table == tablesCount-1)) {
 			i = (tablesCount-1)*columnsPerTable;
 			toI = (tablesCount-1)* columnsPerTable + remainingColumns;
 		}
 
 		for (; i<toI; ++i) {
 			headerString = m_tableView->model()->headerData(i, Qt::Horizontal).toString();
 			w = /*m_tableView->columnWidth(i)*/ firstRowCeilSizes[i];
 			tr.setTopLeft(QPoint(right,height));
 			tr.setWidth(w);
 			tr.setHeight(br.height());
 
 			painter.drawText(tr, Qt::AlignCenter, headerString);
 			right += w;
 			painter.drawLine(right, height, right, height+tr.height());
 
 		}
 		//first horizontal line
 		painter.drawLine(margin + vertHeaderWidth, height, right-1, height);
 		height += tr.height();
 		painter.drawLine(margin, height, right-1, height);
 
 		// print table values
 		QString cellText;
 		for (i=0; i<rows; ++i) {
 			right = margin;
 			cellText = m_tableView->model()->headerData(i, Qt::Vertical).toString()+'\t';
 			tr = painter.boundingRect(tr, Qt::AlignCenter, cellText);
 			painter.drawLine(right, height, right, height+tr.height());
 
 			br.setTopLeft(QPoint(right,height));
 			br.setWidth(vertHeaderWidth);
 			br.setHeight(tr.height());
 			painter.drawText(br, Qt::AlignCenter, cellText);
 			right += vertHeaderWidth;
 			painter.drawLine(right, height, right, height+tr.height());
 			int j = table * columnsPerTable;
 			int toJ = table * columnsPerTable + columnsPerTable;
 			if ((remainingColumns > 0) && (table == tablesCount-1)) {
 				j = (tablesCount-1)*columnsPerTable;
 				toJ = (tablesCount-1)* columnsPerTable + remainingColumns;
 			}
 			for (; j< toJ; j++) {
 				int w = /*m_tableView->columnWidth(j)*/ firstRowCeilSizes[j];
 				cellText = QString::number(data->at(j)[i]) + '\t';
 				tr = painter.boundingRect(tr,Qt::AlignCenter,cellText);
 				br.setTopLeft(QPoint(right,height));
 				br.setWidth(w);
 				br.setHeight(tr.height());
 				painter.drawText(br, Qt::AlignCenter, cellText);
 				right += w;
 				painter.drawLine(right, height, right, height+tr.height());
 			}
 			height += br.height();
 			painter.drawLine(margin, height, right-1, height);
 
 			if (height >= printer->height()-margin ) {
 				printer->newPage();
 				height = margin;
 				painter.drawLine(margin, height, right, height);
 			}
 		}
 	}
 	RESET_CURSOR;
 }
 
 void MatrixView::exportToFile(const QString& path, const QString& separator, QLocale::Language language) const {
 	QFile file(path);
 	if (!file.open(QFile::WriteOnly | QFile::Truncate))
 		return;
 
 	QTextStream out(&file);
 
 	QString sep = separator;
 	sep = sep.replace(QLatin1String("TAB"), QLatin1String("\t"), Qt::CaseInsensitive);
 	sep = sep.replace(QLatin1String("SPACE"), QLatin1String(" "), Qt::CaseInsensitive);
 
 	//export values
 	const int cols = m_matrix->columnCount();
 	const int rows = m_matrix->rowCount();
 	const QVector<QVector<double> >* data = static_cast<QVector<QVector<double>>*>(m_matrix->data());
 	QLocale locale(language);
 	for (int row = 0; row < rows; ++row) {
 		for (int col=0; col<cols; ++col) {
 			out << locale.toString(data->at(col)[row], m_matrix->numericFormat(), m_matrix->precision());
 
 			out << data->at(col)[row];
 			if (col!=cols-1)
 				out<<sep;
 		}
 		out << '\n';
 	}
 }
 
 void MatrixView::exportToLaTeX(const QString& path, const bool verticalHeaders, const bool horizontalHeaders,
                                const bool latexHeaders, const bool gridLines, const bool entire, const bool captions) const {
 	QFile file(path);
 	if (!file.open(QFile::WriteOnly | QFile::Truncate))
 		return;
 
 	QVector<QVector<QString> > toExport;
 
 	int firstSelectedCol = 0;
 	int firstSelectedRowi = 0;
 	int totalRowCount = 0;
 	int cols = 0;
 	if (entire) {
 		cols = m_matrix->columnCount();
 		totalRowCount = m_matrix->rowCount();
 		toExport.reserve(totalRowCount);
 		toExport.resize(totalRowCount);
 		for (int row = 0; row < totalRowCount; ++row) {
 			toExport[row].reserve(cols);
 			toExport[row].resize(cols);
 			//TODO: mode
 			for (int col = 0; col < cols; ++col)
 				toExport[row][col] = m_matrix->text<double>(row,col);
 		}
 		firstSelectedCol = 0;
 		firstSelectedRowi = 0;
 	} else {
 		cols = selectedColumnCount();
 		totalRowCount = selectedRowCount();
 
 		firstSelectedCol = firstSelectedColumn();
 		if (firstSelectedCol == -1)
 			return;
 		firstSelectedRowi = firstSelectedRow();
 		if (firstSelectedRowi == -1)
 			return;
 		const int lastSelectedCol = lastSelectedColumn();
 		const int lastSelectedRowi = lastSelectedRow();
 
 		toExport.reserve(lastSelectedRowi - firstSelectedRowi+1);
 		toExport.resize(lastSelectedRowi - firstSelectedRowi+1);
 		int r = 0;
 		int c = 0;
 		for (int row = firstSelectedRowi; row <= lastSelectedRowi; ++row, ++r) {
 			toExport[r].reserve(lastSelectedCol - firstSelectedCol+1);
 			toExport[r].resize(lastSelectedCol - firstSelectedCol+1);
 			c = 0;
 			//TODO: mode
 			for (int col = firstSelectedCol; col <= lastSelectedCol; ++col,++c)
 				toExport[r][c] = m_matrix->text<double>(row, col);
 		}
 	}
 
 	int columnsStringSize = 0;
 	int headerStringSize = 0;
 	int columnsPerTable = 0;
 	const int firstHHeaderSectionLength = m_tableView->model()->headerData(0, Qt::Horizontal).toString().length();
 	const int firstSelectedVHeaderSectionLength = m_tableView->model()->headerData(firstSelectedRow(), Qt::Vertical).toString().length();
 	if (verticalHeaders) {
 		if (entire)
 			headerStringSize += firstHHeaderSectionLength;
 		else
 			headerStringSize += firstSelectedVHeaderSectionLength;
 	}
 	if (!horizontalHeaders && verticalHeaders) {
 		if (entire)
 			columnsStringSize += firstHHeaderSectionLength;
 		else
 			columnsStringSize += firstSelectedVHeaderSectionLength;
 	}
 
 	for (int col = 0; col < cols; ++col) {
 		int maxSize = -1;
-		for (auto row: toExport) {
+		for (auto row : toExport) {
 			if (row.at(col).size() > maxSize)
 				maxSize = row.at(col).size();
 		}
 		columnsStringSize += maxSize;
 		if (horizontalHeaders)
 			headerStringSize += m_tableView->model()->headerData(col, Qt::Horizontal).toString().length();
 		if ((columnsStringSize > 65) || (headerStringSize > 65))
 			break;
 		++columnsPerTable;
 	}
 
 	int tablesCount = (columnsPerTable != 0) ? cols/columnsPerTable : 0;
 	const int remainingColumns = (columnsPerTable != 0) ? cols % columnsPerTable : cols;
 
 	bool columnsSeparating = (cols > columnsPerTable);
 	QTextStream out(&file);
 
 	QProcess tex;
 	tex.start("latex", QStringList() << "--version", QProcess::ReadOnly);
 	tex.waitForFinished(500);
 	QString texVersionOutput = QString(tex.readAllStandardOutput());
 	texVersionOutput = texVersionOutput.split('\n')[0];
 
 	int yearidx = -1;
 	for (int i = texVersionOutput.size() - 1; i >= 0; --i) {
 		if (texVersionOutput.at(i) == QChar('2')) {
 			yearidx = i;
 			break;
 		}
 	}
 
 	if (texVersionOutput.at(yearidx+1) == QChar('/'))
 		yearidx-=3;
 
 	bool ok;
 	texVersionOutput.midRef(yearidx, 4).toInt(&ok);
 	int version = -1;
 	if (ok)
 		version = texVersionOutput.midRef(yearidx, 4).toInt(&ok);
 
 	if (latexHeaders) {
 		out << QLatin1String("\\documentclass[11pt,a4paper]{article} \n");
 		out << QLatin1String("\\usepackage{geometry} \n");
 		out << QLatin1String("\\usepackage{xcolor,colortbl} \n");
 		if (version >= 2015)
 			out << QLatin1String("\\extrafloats{1280} \n");
 		out << QLatin1String("\\definecolor{HeaderBgColor}{rgb}{0.81,0.81,0.81} \n");
 		out << QLatin1String("\\geometry{ \n");
 		out << QLatin1String("a4paper, \n");
 		out << QLatin1String("total={170mm,257mm}, \n");
 		out << QLatin1String("left=10mm, \n");
 		out << QLatin1String("top=10mm } \n");
 
 		out << QLatin1String("\\begin{document} \n");
 		out << QLatin1String("\\title{LabPlot Matrix Export to \\LaTeX{} } \n");
 		out << QLatin1String("\\author{LabPlot} \n");
 		out << QLatin1String("\\date{\\today} \n");
 		// out << "\\maketitle \n";
 	}
 
 	const QString endTabularTable ("\\end{tabular} \n \\end{table} \n");
 	const QString tableCaption ("\\caption{"+ m_matrix->name() + "} \n");
 	const QString beginTable ("\\begin{table}[ht] \n");
 	const QString centeredColumn( gridLines ? QLatin1String(" c |") : QLatin1String(" c "));
 	int rowCount = 0;
 	const int maxRows = 45;
 	bool captionRemoved = false;
 
 	if (columnsSeparating) {
 		for (int table = 0; table < tablesCount; ++table) {
 			QStringList textable;
 			captionRemoved = false;
 
 			textable << beginTable;
 			if (captions)
 				textable << tableCaption;
 			textable << QLatin1String("\\centering \n");
 			textable << QLatin1String("\\begin{tabular}{");
 			textable<< (gridLines ?QLatin1String("|") : QLatin1String(""));
 			for (int i = 0; i < columnsPerTable; ++i)
 				textable << centeredColumn;
 			if (verticalHeaders)
 				textable << centeredColumn;
 			textable << QLatin1String("} \n");
 			if (gridLines)
 				textable << QLatin1String("\\hline \n");
 
 			if (horizontalHeaders) {
 				if (latexHeaders)
 					textable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 				if (verticalHeaders)
 					textable << QLatin1String(" & ");
 				for (int col = table*columnsPerTable; col < (table * columnsPerTable) + columnsPerTable; ++col) {
 					textable << m_tableView->model()->headerData(col + firstSelectedCol, Qt::Horizontal).toString();
 					if (col != ((table * columnsPerTable)+ columnsPerTable)-1)
 						textable << QLatin1String(" & ");
 				}
 				textable << QLatin1String("\\\\ \n");
 				if (gridLines)
 					textable << QLatin1String("\\hline \n");
 			}
 			for (const auto& s : textable)
 				out << s;
 			for (int row = 0; row < totalRowCount; ++row) {
 				if (verticalHeaders) {
 					out << "\\cellcolor{HeaderBgColor} ";
 					out << m_tableView->model()->headerData(row + firstSelectedRowi, Qt::Vertical).toString();
 					out << QLatin1String(" & ");
 				}
 				for (int col = table*columnsPerTable; col < (table * columnsPerTable) + columnsPerTable; ++col ) {
 					out << toExport.at(row).at(col);
 					if (col != ((table * columnsPerTable)+ columnsPerTable)-1)
 						out << QLatin1String(" & ");
 				}
 
 				out << QLatin1String("\\\\ \n");
 				if (gridLines)
 					out << QLatin1String("\\hline \n");
 				rowCount++;
 				if (rowCount == maxRows) {
 					out << endTabularTable;
 					out << QLatin1String("\\newpage \n");
 					if (captions)
 						if (!captionRemoved)
 							textable.removeAt(1);
 					for (const auto& s : textable)
 						out << s;
 					rowCount = 0;
 					if (!captionRemoved)
 						captionRemoved = true;
 				}
 			}
 			out << endTabularTable;
 		}
 		captionRemoved = false;
 
 		QStringList remainingTable;
 		remainingTable << beginTable;
 		if (captions)
 			remainingTable << tableCaption;
 		remainingTable << QLatin1String("\\centering \n");
 		remainingTable << QLatin1String("\\begin{tabular}{") <<  (gridLines ? QLatin1String("|"):QLatin1String(""));
 		for (int c = 0; c < remainingColumns; ++c)
 			remainingTable << centeredColumn;
 		if (verticalHeaders)
 			remainingTable << centeredColumn;
 		remainingTable << QLatin1String("} \n");
 		if (gridLines)
 			remainingTable << QLatin1String("\\hline \n");
 
 		if (horizontalHeaders) {
 			if (latexHeaders)
 				remainingTable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 			if (verticalHeaders)
 				remainingTable << QLatin1String(" & ");
 			for (int col = 0; col < remainingColumns; ++col) {
 				remainingTable << m_tableView->model()->headerData(firstSelectedCol+col + (tablesCount * columnsPerTable), Qt::Horizontal).toString();
 				if (col != remainingColumns-1)
 					remainingTable << QLatin1String(" & ");
 			}
 			remainingTable << QLatin1String("\\\\ \n");
 			if (gridLines)
 				remainingTable << QLatin1String("\\hline \n");
 		}
 
 		for (const auto& s : remainingTable)
 			out << s;
 
 		for (int row = 0; row < totalRowCount; ++row) {
 			if (verticalHeaders) {
 				out << "\\cellcolor{HeaderBgColor}";
 				out << m_tableView->model()->headerData(row+ firstSelectedRowi, Qt::Vertical).toString();
 				out << QLatin1String(" & ");
 			}
 			for (int col = 0; col < remainingColumns; ++col ) {
 				out << toExport.at(row).at(col + (tablesCount * columnsPerTable));
 				if (col != remainingColumns-1)
 					out << QLatin1String(" & ");
 			}
 
 			out << QLatin1String("\\\\ \n");
 			if (gridLines)
 				out << QLatin1String("\\hline \n");
 			rowCount++;
 			if (rowCount == maxRows) {
 				out << endTabularTable;
 				out << QLatin1String("\\pagebreak[4] \n");
 				if (captions)
 					if (!captionRemoved)
 						remainingTable.removeAt(1);
 				for (const auto& s : remainingTable)
 					out << s;
 				rowCount = 0;
 				if (!captionRemoved)
 					captionRemoved = true;
 			}
 		}
 		out << endTabularTable;
 	} else {
 		QStringList textable;
 		textable << beginTable;
 		if (captions)
 			textable << tableCaption;
 		textable << QLatin1String("\\centering \n");
 		textable << QLatin1String("\\begin{tabular}{") << (gridLines ? QLatin1String("|"):QLatin1String(""));
 		for (int c = 0; c < cols; ++c)
 			textable << centeredColumn;
 		if (verticalHeaders)
 			textable << centeredColumn;
 		textable << QLatin1String("} \n");
 		if (gridLines)
 			textable << QLatin1String("\\hline \n");
 
 		if (horizontalHeaders) {
 			if (latexHeaders)
 				textable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 			if (verticalHeaders)
 				textable << QLatin1String(" & ");
 			for (int col = 0; col < cols ; ++col) {
 				textable << m_tableView->model()->headerData(col+firstSelectedCol, Qt::Horizontal).toString();
 				if (col != cols-1)
 					textable << QLatin1String(" & ");
 			}
 			textable << QLatin1String("\\\\ \n");
 			if (gridLines)
 				textable << QLatin1String("\\hline \n");
 		}
 
 		for (const auto& s : textable)
 			out << s;
 		for (int row = 0; row < totalRowCount; ++row) {
 			if (verticalHeaders) {
 				out << "\\cellcolor{HeaderBgColor}";
 				out << m_tableView->model()->headerData(row + firstSelectedRowi, Qt::Vertical).toString();
 				out << QLatin1String(" & ");
 			}
 			for (int col = 0; col < cols; ++col ) {
 				out << toExport.at(row).at(col);
 				if (col != cols-1)
 					out << " & ";
 			}
 			out << QLatin1String("\\\\ \n");
 			if (gridLines)
 				out << QLatin1String("\\hline \n");
 			rowCount++;
 			if (rowCount == maxRows) {
 				out << endTabularTable;
 				out << QLatin1String("\\newpage \n");
 				if (captions)
 					if (!captionRemoved)
 						textable.removeAt(1);
 				for (const auto& s : textable)
 					out << s;
 				if (!captionRemoved)
 					captionRemoved = true;
 				rowCount = 0;
 				if (!captionRemoved)
 					captionRemoved = true;
 			}
 		}
 		out << endTabularTable;
 	}
 	if (latexHeaders)
 		out << QLatin1String("\\end{document} \n");
 }
 
 void MatrixView::showColumnStatistics() {
 	if (selectedColumnCount() > 0) {
 		QString dlgTitle (m_matrix->name() + " column statistics");
 		StatisticsDialog* dlg = new StatisticsDialog(dlgTitle);
 		QVector<Column*> columns;
 		for (int col = 0; col < m_matrix->columnCount(); ++col) {
 			if (isColumnSelected(col, false)) {
 				QString headerString = m_tableView->model()->headerData(col, Qt::Horizontal).toString();
 				columns << new Column(headerString, static_cast<QVector<QVector<double>>*>(m_matrix->data())->at(col));
 			}
 		}
 		dlg->setColumns(columns);
 		if (dlg->exec() == QDialog::Accepted) {
 			qDeleteAll(columns);
 			columns.clear();
 		}
 	}
 }
 
 void MatrixView::showRowStatistics() {
 	if (selectedRowCount() > 0) {
 		QString dlgTitle (m_matrix->name() + " row statistics");
 		StatisticsDialog* dlg = new StatisticsDialog(dlgTitle);
 		QVector<Column*> columns;
 		for (int row = 0; row < m_matrix->rowCount(); ++row) {
 			if (isRowSelected(row, false)) {
 				QString headerString = m_tableView->model()->headerData(row, Qt::Vertical).toString();
 				//TODO: mode
 				columns << new Column(headerString, m_matrix->rowCells<double>(row, 0, m_matrix->columnCount()-1));
 			}
 		}
 		dlg->setColumns(columns);
 		if (dlg->exec() == QDialog::Accepted) {
 			qDeleteAll(columns);
 			columns.clear();
 		}
 	}
 }
 
 void MatrixView::exportToFits(const QString &fileName, const int exportTo) const {
 	FITSFilter* filter = new FITSFilter;
 	filter->setExportTo(exportTo);
 	filter->write(fileName, m_matrix);
 
 	delete filter;
 }
 
diff --git a/src/commonfrontend/spreadsheet/SpreadsheetView.cpp b/src/commonfrontend/spreadsheet/SpreadsheetView.cpp
index 7f164a2ab..8b91fec98 100644
--- a/src/commonfrontend/spreadsheet/SpreadsheetView.cpp
+++ b/src/commonfrontend/spreadsheet/SpreadsheetView.cpp
@@ -1,2670 +1,2670 @@
 /***************************************************************************
     File                 : SpreadsheetView.cpp
     Project              : LabPlot
     Description          : View class for Spreadsheet
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2017 by Alexander Semke (alexander.semke@web.de)
 						   (C) 2016      by 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 "SpreadsheetView.h"
 #include "backend/spreadsheet/SpreadsheetModel.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "commonfrontend/spreadsheet/SpreadsheetItemDelegate.h"
 #include "commonfrontend/spreadsheet/SpreadsheetHeaderView.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "backend/lib/macros.h"
 #include "backend/lib/trace.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/column/ColumnPrivate.h"
 #include "backend/core/datatypes/SimpleCopyThroughFilter.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/String2DoubleFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/core/datatypes/String2DateTimeFilter.h"
 
 #include <QKeyEvent>
 #include <QClipboard>
 #include <QInputDialog>
 #include <QDate>
 #include <QApplication>
 #include <QMenu>
 #include <QMimeData>
 #include <QPainter>
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QTableView>
 #include <QToolBar>
 #include <QTextStream>
 #include <QProcess>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include "kdefrontend/spreadsheet/ExportSpreadsheetDialog.h"
 #include "kdefrontend/spreadsheet/PlotDataDialog.h"
 #include "kdefrontend/spreadsheet/DropValuesDialog.h"
 #include "kdefrontend/spreadsheet/SortDialog.h"
 #include "kdefrontend/spreadsheet/RandomValuesDialog.h"
 #include "kdefrontend/spreadsheet/EquidistantValuesDialog.h"
 #include "kdefrontend/spreadsheet/FunctionValuesDialog.h"
 #include "kdefrontend/spreadsheet/StatisticsDialog.h"
 
 #include <algorithm> //for std::reverse
 
 /*!
 	\class SpreadsheetView
 	\brief View class for Spreadsheet
 
 	\ingroup commonfrontend
  */
 SpreadsheetView::SpreadsheetView(Spreadsheet* spreadsheet, bool readOnly) : QWidget(),
 	m_tableView(new QTableView(this)),
 	m_spreadsheet(spreadsheet),
 	m_model( new SpreadsheetModel(spreadsheet) ),
 	m_suppressSelectionChangedEvent(false),
 	m_readOnly(readOnly),
 	m_columnSetAsMenu(nullptr),
 	m_columnGenerateDataMenu(nullptr),
 	m_columnSortMenu(nullptr) {
 
 	QHBoxLayout* layout = new QHBoxLayout(this);
 	layout->setContentsMargins(0,0,0,0);
 	layout->addWidget(m_tableView);
 	if (m_readOnly)
 		m_tableView->setEditTriggers(QTableView::NoEditTriggers);
 	init();
 
 	//resize the view to show alls columns and the first 50 rows.
 	//no need to resize the view when the project is being opened,
 	//all views will be resized to the stored values at the end
 	if (!m_spreadsheet->isLoading()) {
 		int w = m_tableView->verticalHeader()->width();
 		int h = m_horizontalHeader->height();
 		for (int i = 0; i < m_horizontalHeader->count(); ++i)
 			w += m_horizontalHeader->sectionSize(i);
 
 		if (m_tableView->verticalHeader()->count() > 50 || m_tableView->verticalHeader()->count() < 10)
 			h += m_tableView->verticalHeader()->sectionSize(0)*50;
 		else
 			h += m_tableView->verticalHeader()->sectionSize(0)*m_tableView->verticalHeader()->count();
 
 		resize(w+50, h);
 	}
 
 	KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Spreadsheet"));
 	showComments(group.readEntry(QLatin1String("ShowComments"), false));
 }
 
 SpreadsheetView::~SpreadsheetView() {
 	delete m_model;
 }
 
 void SpreadsheetView::init() {
 	initActions();
 	initMenus();
 
 	m_tableView->setModel(m_model);
 	m_tableView->setItemDelegate(new SpreadsheetItemDelegate(this));
 	m_tableView->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
 	//horizontal header
 	m_horizontalHeader = new SpreadsheetHeaderView(this);
 	m_horizontalHeader->setSectionsClickable(true);
 	m_horizontalHeader->setHighlightSections(true);
 	m_tableView->setHorizontalHeader(m_horizontalHeader);
 	m_horizontalHeader->setSectionsMovable(true);
 	m_horizontalHeader->installEventFilter(this);
 
 	resizeHeader();
 
 	connect(m_horizontalHeader, SIGNAL(sectionMoved(int,int,int)), this, SLOT(handleHorizontalSectionMoved(int,int,int)));
 	connect(m_horizontalHeader, SIGNAL(sectionDoubleClicked(int)), this, SLOT(handleHorizontalHeaderDoubleClicked(int)));
 	connect(m_horizontalHeader, SIGNAL(sectionResized(int,int,int)), this, SLOT(handleHorizontalSectionResized(int,int,int)));
 	connect(m_horizontalHeader, SIGNAL(sectionClicked(int)), this, SLOT(columnClicked(int)) );
 
 	// vertical header
 	QHeaderView* v_header = m_tableView->verticalHeader();
 	v_header->setSectionResizeMode(QHeaderView::Fixed);
 	v_header->setSectionsMovable(false);
 	v_header->installEventFilter(this);
 
 	setFocusPolicy(Qt::StrongFocus);
 	setFocus();
 	installEventFilter(this);
 	connectActions();
 	showComments(false);
 
 	connect(m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), this,
 	        SLOT(updateHeaderGeometry(Qt::Orientation,int,int)) );
 	connect(m_model, SIGNAL(headerDataChanged(Qt::Orientation,int,int)), this,
 	        SLOT(handleHeaderDataChanged(Qt::Orientation,int,int)) );
 	connect(m_spreadsheet, SIGNAL(aspectAdded(const AbstractAspect*)),
 	        this, SLOT(handleAspectAdded(const AbstractAspect*)));
 	connect(m_spreadsheet, SIGNAL(aspectAboutToBeRemoved(const AbstractAspect*)),
 	        this, SLOT(handleAspectAboutToBeRemoved(const AbstractAspect*)));
 	connect(m_spreadsheet, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)));
 
-	for (auto* column: m_spreadsheet->children<Column>())
+	for (auto* column : m_spreadsheet->children<Column>())
 		connect(column, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createColumnContextMenu(QMenu*)));
 
 	//selection relevant connections
 	QItemSelectionModel* sel_model = m_tableView->selectionModel();
 	connect(sel_model, SIGNAL(currentColumnChanged(QModelIndex,QModelIndex)),
 	        this, SLOT(currentColumnChanged(QModelIndex,QModelIndex)));
 	connect(sel_model, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 	        this, SLOT(selectionChanged(QItemSelection,QItemSelection)));
 	connect(sel_model, SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 	        this, SLOT(selectionChanged(QItemSelection,QItemSelection)) );
 
 	connect(m_spreadsheet, SIGNAL(columnSelected(int)), this, SLOT(selectColumn(int)) );
 	connect(m_spreadsheet, SIGNAL(columnDeselected(int)), this, SLOT(deselectColumn(int)) );
 }
 
 /*!
 	set the column sizes to the saved values or resize to content if no size was saved yet
 */
 void SpreadsheetView::resizeHeader() {
 	for (int i = 0; i < m_spreadsheet->children<Column>().size(); ++i) {
 		Column* col = m_spreadsheet->child<Column>(i);
 		if (col->width() == 0)
 			m_tableView->resizeColumnToContents(i);
 		else
 			m_tableView->setColumnWidth(i, col->width());
 	}
 }
 
 void SpreadsheetView::initActions() {
 	// selection related actions
 	action_cut_selection = new QAction(QIcon::fromTheme("edit-cut"), i18n("Cu&t"), this);
 	action_copy_selection = new QAction(QIcon::fromTheme("edit-copy"), i18n("&Copy"), this);
 	action_paste_into_selection = new QAction(QIcon::fromTheme("edit-paste"), i18n("Past&e"), this);
 	action_mask_selection = new QAction(QIcon::fromTheme("edit-node"), i18n("&Mask Selection"), this);
 	action_unmask_selection = new QAction(QIcon::fromTheme("format-remove-node"), i18n("&Unmask Selection"), this);
 	action_clear_selection = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clea&r Selection"), this);
 	action_select_all = new QAction(QIcon::fromTheme("edit-select-all"), i18n("Select All"), this);
 
 // 	action_set_formula = new QAction(QIcon::fromTheme(""), i18n("Assign &Formula"), this);
 // 	action_recalculate = new QAction(QIcon::fromTheme(""), i18n("Recalculate"), this);
 	action_fill_sel_row_numbers = new QAction(QIcon::fromTheme(""), i18n("Row Numbers"), this);
 	action_fill_row_numbers = new QAction(QIcon::fromTheme(""), i18n("Row Numbers"), this);
 	action_fill_random = new QAction(QIcon::fromTheme(""), i18n("Uniform Random Values"), this);
 	action_fill_random_nonuniform = new QAction(QIcon::fromTheme(""), i18n("Random Values"), this);
 	action_fill_equidistant = new QAction(QIcon::fromTheme(""), i18n("Equidistant Values"), this);
 	action_fill_function = new QAction(QIcon::fromTheme(""), i18n("Function Values"), this);
 	action_fill_const = new QAction(QIcon::fromTheme(""), i18n("Const Values"), this);
 
 	//spreadsheet related actions
 	action_toggle_comments = new QAction(QIcon::fromTheme("document-properties"), i18n("Show Comments"), this);
 	action_clear_spreadsheet = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clear Spreadsheet"), this);
 	action_clear_masks = new QAction(QIcon::fromTheme("format-remove-node"), i18n("Clear Masks"), this);
 	action_sort_spreadsheet = new QAction(QIcon::fromTheme("view-sort-ascending"), i18n("&Sort Spreadsheet"), this);
 	action_go_to_cell = new QAction(QIcon::fromTheme("go-jump"), i18n("&Go to Cell"), this);
 	action_statistics_all_columns = new QAction(QIcon::fromTheme("view-statistics"), i18n("Statisti&cs"), this );
 
 	// column related actions
 	action_insert_column_left = new QAction(QIcon::fromTheme("edit-table-insert-column-left"), i18n("Insert Column Left"), this);
 	action_insert_column_right = new QAction(QIcon::fromTheme("edit-table-insert-column-right"), i18n("Insert Column Right"), this);
 	action_remove_columns = new QAction(QIcon::fromTheme("edit-table-delete-column"), i18n("Remove Selected Columns"), this);
 	action_clear_columns = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clear Selected Columns"), this);
 
 	action_set_as_none = new QAction(i18n("None"), this);
 	action_set_as_none->setData(AbstractColumn::NoDesignation);
 
 	action_set_as_x = new QAction("X", this);
 	action_set_as_x->setData(AbstractColumn::X);
 
 	action_set_as_y = new QAction("Y", this);
 	action_set_as_y->setData(AbstractColumn::Y);
 
 	action_set_as_z = new QAction("Z", this);
 	action_set_as_z->setData(AbstractColumn::Z);
 
 	action_set_as_xerr = new QAction(i18n("X-error"), this);
 	action_set_as_xerr->setData(AbstractColumn::XError);
 
 	action_set_as_xerr_minus = new QAction(i18n("X-error minus"), this);
 	action_set_as_xerr_minus->setData(AbstractColumn::XErrorMinus);
 
 	action_set_as_xerr_plus = new QAction(i18n("X-error plus"), this);
 	action_set_as_xerr_plus->setData(AbstractColumn::XErrorPlus);
 
 	action_set_as_yerr = new QAction(i18n("Y-error"), this);
 	action_set_as_yerr->setData(AbstractColumn::YError);
 
 	action_set_as_yerr_minus = new QAction(i18n("Y-error minus"), this);
 	action_set_as_yerr_minus->setData(AbstractColumn::YErrorMinus);
 
 	action_set_as_yerr_plus = new QAction(i18n("Y-error plus"), this);
 	action_set_as_yerr_plus->setData(AbstractColumn::YErrorPlus);
 
 	action_reverse_columns = new QAction(QIcon::fromTheme(""), i18n("Reverse"), this);
 	action_drop_values = new QAction(QIcon::fromTheme(""), i18n("Drop Values"), this);
 	action_mask_values = new QAction(QIcon::fromTheme(""), i18n("Mask Values"), this);
 // 	action_join_columns = new QAction(QIcon::fromTheme(""), i18n("Join"), this);
 	action_normalize_columns = new QAction(QIcon::fromTheme(""), i18n("&Normalize"), this);
 	action_normalize_selection = new QAction(QIcon::fromTheme(""), i18n("&Normalize Selection"), this);
 	action_sort_columns = new QAction(QIcon::fromTheme(""), i18n("&Selected Columns"), this);
 	action_sort_asc_column = new QAction(QIcon::fromTheme("view-sort-ascending"), i18n("&Ascending"), this);
 	action_sort_desc_column = new QAction(QIcon::fromTheme("view-sort-descending"), i18n("&Descending"), this);
 	action_statistics_columns = new QAction(QIcon::fromTheme("view-statistics"), i18n("Column Statisti&cs"), this);
 
 	// row related actions
 	action_insert_row_above = new QAction(QIcon::fromTheme("edit-table-insert-row-above") ,i18n("Insert Row Above"), this);
 	action_insert_row_below = new QAction(QIcon::fromTheme("edit-table-insert-row-below"), i18n("Insert Row Below"), this);
 	action_remove_rows = new QAction(QIcon::fromTheme("edit-table-delete-row"), i18n("Remo&ve Selected Rows"), this);
 	action_clear_rows = new QAction(QIcon::fromTheme("edit-clear"), i18n("Clea&r Selected Rows"), this);
 	action_statistics_rows = new QAction(QIcon::fromTheme("view-statistics"), i18n("Row Statisti&cs"), this);
 
 	//plot data action
 	action_plot_data_xycurve = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("xy-Curve"), this);
 	action_plot_data_xycurve->setData(PlotDataDialog::PlotXYCurve);
 	action_plot_data_histogram = new QAction(QIcon::fromTheme("labplot-histogram"), i18n("Histogram"), this);
 	action_plot_data_histogram->setData(PlotDataDialog::PlotHistogram);
 
 	//Analyze and plot menu actions
 	//TODO: no own icons yet
 	addDataOperationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Operation"), this);
 //	addDataOperationAction = new QAction(QIcon::fromTheme("labplot-xy-data-operation-curve"), i18n("Data Operation"), this);
 	//TODO: enable when available
 	addDataOperationAction->setEnabled(false);
 	addDataReductionAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Reduce Data"), this);
 //	addDataReductionAction = new QAction(QIcon::fromTheme("labplot-xy-data-reduction-curve"), i18n("Reduce Data"), this);
 	addDataReductionAction->setData(PlotDataDialog::DataReduction);
 	addDifferentiationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Differentiate"), this);
 //	addDifferentiationAction = new QAction(QIcon::fromTheme("labplot-xy-differentiation-curve"), i18n("Differentiate"), this);
 	addDifferentiationAction->setData(PlotDataDialog::Differentiation);
 	addIntegrationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Integrate"), this);
 //	addIntegrationAction = new QAction(QIcon::fromTheme("labplot-xy-integration-curve"), i18n("Integrate"), this);
 	addIntegrationAction->setData(PlotDataDialog::Integration);
 	addInterpolationAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("Interpolate"), this);
 	addInterpolationAction->setData(PlotDataDialog::Interpolation);
 	addSmoothAction = new QAction(QIcon::fromTheme("labplot-xy-smoothing-curve"), i18n("Smooth"), this);
 	addSmoothAction->setData(PlotDataDialog::Smoothing);
 
 	QAction* fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Linear"), this);
 	fitAction->setData(PlotDataDialog::FitLinear);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Power"), this);
 	fitAction->setData(PlotDataDialog::FitPower);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Exponential (degree 1)"), this);
 	fitAction->setData(PlotDataDialog::FitExp1);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Exponential (degree 2)"), this);
 	fitAction->setData(PlotDataDialog::FitExp2);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Inverse Exponential"), this);
 	fitAction->setData(PlotDataDialog::FitInvExp);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Gauss"), this);
 	fitAction->setData(PlotDataDialog::FitGauss);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Cauchy-Lorentz"), this);
 	fitAction->setData(PlotDataDialog::FitCauchyLorentz);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Arc Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTan);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Hyperbolic Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTanh);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Error Function"), this);
 	fitAction->setData(PlotDataDialog::FitErrFunc);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Custom"), this);
 	fitAction->setData(PlotDataDialog::FitCustom);
 	addFitAction.append(fitAction);
 
 	addFourierFilterAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-filter-curve"), i18n("Fourier Filter"), this);
 	addFourierFilterAction->setData(PlotDataDialog::FourierFilter);
 }
 
 void SpreadsheetView::initMenus() {
 	//Selection menu
 	m_selectionMenu = new QMenu(i18n("Selection"), this);
 	QMenu* submenu = nullptr;
 
 	if (!m_readOnly) {
 		submenu= new QMenu(i18n("Fi&ll Selection With"), this);
 		submenu->addAction(action_fill_sel_row_numbers);
 		submenu->addAction(action_fill_const);
 		m_selectionMenu->addMenu(submenu);
 		m_selectionMenu->addSeparator();
 		m_selectionMenu->addAction(action_cut_selection);
 	}
 
 	m_selectionMenu->addAction(action_copy_selection);
 
 	if (!m_readOnly) {
 		m_selectionMenu->addAction(action_paste_into_selection);
 		m_selectionMenu->addAction(action_clear_selection);
 		m_selectionMenu->addSeparator();
 		m_selectionMenu->addAction(action_mask_selection);
 		m_selectionMenu->addAction(action_unmask_selection);
 		m_selectionMenu->addSeparator();
 		m_selectionMenu->addAction(action_normalize_selection);
 	}
 
 	//plot data menu
 	m_plotDataMenu = new QMenu(i18n("Plot Data"), this);
 	m_plotDataMenu->addAction(action_plot_data_xycurve);
 	m_plotDataMenu->addAction(action_plot_data_histogram);
 
 	// Column menu
 	m_columnMenu = new QMenu(this);
 	m_columnMenu->addMenu(m_plotDataMenu);
 
 	// Data manipulation sub-menu
 	QMenu* dataManipulationMenu = new QMenu(i18n("Data Manipulation"));
 	dataManipulationMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	dataManipulationMenu->addAction(addDataOperationAction);
 	dataManipulationMenu->addAction(addDataReductionAction);
 
 	// Data fit sub-menu
 	QMenu* dataFitMenu = new QMenu(i18n("Fit"));
 	dataFitMenu->setIcon(QIcon::fromTheme("labplot-xy-fit-curve"));
 	dataFitMenu->addAction(addFitAction.at(0));
 	dataFitMenu->addAction(addFitAction.at(1));
 	dataFitMenu->addAction(addFitAction.at(2));
 	dataFitMenu->addAction(addFitAction.at(3));
 	dataFitMenu->addAction(addFitAction.at(4));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(5));
 	dataFitMenu->addAction(addFitAction.at(6));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(7));
 	dataFitMenu->addAction(addFitAction.at(8));
 	dataFitMenu->addAction(addFitAction.at(9));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(10));
 
 	//analyze and plot data menu
 	m_analyzePlotMenu = new QMenu(i18n("Analyze and Plot Data"));
 	m_analyzePlotMenu->insertMenu(nullptr, dataManipulationMenu);
 	m_analyzePlotMenu->addSeparator();
 	m_analyzePlotMenu->addAction(addDifferentiationAction);
 	m_analyzePlotMenu->addAction(addIntegrationAction);
 	m_analyzePlotMenu->addSeparator();
 	m_analyzePlotMenu->addAction(addInterpolationAction);
 	m_analyzePlotMenu->addAction(addSmoothAction);
 	m_analyzePlotMenu->addAction(addFourierFilterAction);
 	m_analyzePlotMenu->addSeparator();
 	m_analyzePlotMenu->addMenu(dataFitMenu);
 	m_columnMenu->addMenu(m_analyzePlotMenu);
 
 	m_columnSetAsMenu = new QMenu(i18n("Set Column As"));
 	m_columnMenu->addSeparator();
 	m_columnSetAsMenu->addAction(action_set_as_x);
 	m_columnSetAsMenu->addAction(action_set_as_y);
 	m_columnSetAsMenu->addAction(action_set_as_z);
 	m_columnSetAsMenu->addSeparator();
 	m_columnSetAsMenu->addAction(action_set_as_xerr);
 	m_columnSetAsMenu->addAction(action_set_as_xerr_minus);
 	m_columnSetAsMenu->addAction(action_set_as_xerr_plus);
 	m_columnSetAsMenu->addSeparator();
 	m_columnSetAsMenu->addAction(action_set_as_yerr);
 	m_columnSetAsMenu->addAction(action_set_as_yerr_minus);
 	m_columnSetAsMenu->addAction(action_set_as_yerr_plus);
 	m_columnSetAsMenu->addSeparator();
 	m_columnSetAsMenu->addAction(action_set_as_none);
 	m_columnMenu->addMenu(m_columnSetAsMenu);
 
 	if (!m_readOnly) {
 		m_columnGenerateDataMenu = new QMenu(i18n("Generate Data"), this);
 		m_columnGenerateDataMenu->addAction(action_fill_row_numbers);
 		m_columnGenerateDataMenu->addAction(action_fill_const);
 		m_columnGenerateDataMenu->addAction(action_fill_equidistant);
 		m_columnGenerateDataMenu->addAction(action_fill_random_nonuniform);
 		m_columnGenerateDataMenu->addAction(action_fill_function);
 		m_columnMenu->addSeparator();
 		m_columnMenu->addMenu(m_columnGenerateDataMenu);
 		m_columnMenu->addSeparator();
 
 		m_columnMenu->addAction(action_reverse_columns);
 		m_columnMenu->addAction(action_drop_values);
 		m_columnMenu->addAction(action_mask_values);
 		// 	m_columnMenu->addAction(action_join_columns);
 		m_columnMenu->addAction(action_normalize_columns);
 
 		m_columnSortMenu = new QMenu(i18n("Sort"), this);
 		m_columnSortMenu->setIcon(QIcon::fromTheme("view-sort-ascending"));
 		m_columnSortMenu->addAction(action_sort_asc_column);
 		m_columnSortMenu->addAction(action_sort_desc_column);
 		m_columnSortMenu->addAction(action_sort_columns);
 		m_columnMenu->addSeparator();
 		m_columnMenu->addMenu(m_columnSortMenu);
 		m_columnMenu->addSeparator();
 
 		m_columnMenu->addAction(action_insert_column_left);
 		m_columnMenu->addAction(action_insert_column_right);
 		m_columnMenu->addSeparator();
 		m_columnMenu->addAction(action_remove_columns);
 		m_columnMenu->addAction(action_clear_columns);
 	}
 	m_columnMenu->addSeparator();
 	m_columnMenu->addAction(action_toggle_comments);
 	m_columnMenu->addSeparator();
 
 	m_columnMenu->addAction(action_statistics_columns);
 	action_statistics_columns->setVisible(false);
 
 	//Spreadsheet menu
 	m_spreadsheetMenu = new QMenu(this);
 	m_spreadsheetMenu->addMenu(m_plotDataMenu);
 	m_spreadsheetMenu->addMenu(m_analyzePlotMenu);
 	m_spreadsheetMenu->addSeparator();
 	m_spreadsheetMenu->addMenu(m_selectionMenu);
 	m_spreadsheetMenu->addSeparator();
 	m_spreadsheetMenu->addAction(action_select_all);
 	if (!m_readOnly) {
 		m_spreadsheetMenu->addAction(action_clear_spreadsheet);
 		m_spreadsheetMenu->addAction(action_clear_masks);
 		m_spreadsheetMenu->addAction(action_sort_spreadsheet);
 	}
 	m_spreadsheetMenu->addSeparator();
 	m_spreadsheetMenu->addAction(action_go_to_cell);
 	m_spreadsheetMenu->addSeparator();
 	m_spreadsheetMenu->addAction(action_toggle_comments);
 	m_spreadsheetMenu->addSeparator();
 	m_spreadsheetMenu->addAction(action_statistics_all_columns);
 	action_statistics_all_columns->setVisible(true);
 
 	//Row menu
 	m_rowMenu = new QMenu(this);
 	if (!m_readOnly) {
 		submenu = new QMenu(i18n("Fi&ll Selection With"), this);
 		submenu->addAction(action_fill_sel_row_numbers);
 		submenu->addAction(action_fill_const);
 		m_rowMenu->addMenu(submenu);
 		m_rowMenu->addSeparator();
 
 		m_rowMenu->addAction(action_insert_row_above);
 		m_rowMenu->addAction(action_insert_row_below);
 		m_rowMenu->addSeparator();
 
 		m_rowMenu->addAction(action_remove_rows);
 		m_rowMenu->addAction(action_clear_rows);
 	}
 	m_rowMenu->addSeparator();
 	m_rowMenu->addAction(action_statistics_rows);
 	action_statistics_rows->setVisible(false);
 }
 
 void SpreadsheetView::connectActions() {
 	connect(action_cut_selection, SIGNAL(triggered()), this, SLOT(cutSelection()));
 	connect(action_copy_selection, SIGNAL(triggered()), this, SLOT(copySelection()));
 	connect(action_paste_into_selection, SIGNAL(triggered()), this, SLOT(pasteIntoSelection()));
 	connect(action_mask_selection, SIGNAL(triggered()), this, SLOT(maskSelection()));
 	connect(action_unmask_selection, SIGNAL(triggered()), this, SLOT(unmaskSelection()));
 
 	connect(action_clear_selection, SIGNAL(triggered()), this, SLOT(clearSelectedCells()));
 // 	connect(action_recalculate, SIGNAL(triggered()), this, SLOT(recalculateSelectedCells()));
 	connect(action_fill_row_numbers, SIGNAL(triggered()), this, SLOT(fillWithRowNumbers()));
 	connect(action_fill_sel_row_numbers, SIGNAL(triggered()), this, SLOT(fillSelectedCellsWithRowNumbers()));
 // 	connect(action_fill_random, SIGNAL(triggered()), this, SLOT(fillSelectedCellsWithRandomNumbers()));
 	connect(action_fill_random_nonuniform, SIGNAL(triggered()), this, SLOT(fillWithRandomValues()));
 	connect(action_fill_equidistant, SIGNAL(triggered()), this, SLOT(fillWithEquidistantValues()));
 	connect(action_fill_function, SIGNAL(triggered()), this, SLOT(fillWithFunctionValues()));
 	connect(action_fill_const, SIGNAL(triggered()), this, SLOT(fillSelectedCellsWithConstValues()));
 	connect(action_select_all, SIGNAL(triggered()), m_tableView, SLOT(selectAll()));
 	connect(action_clear_spreadsheet, SIGNAL(triggered()), m_spreadsheet, SLOT(clear()));
 	connect(action_clear_masks, SIGNAL(triggered()), m_spreadsheet, SLOT(clearMasks()));
 	connect(action_sort_spreadsheet, SIGNAL(triggered()), this, SLOT(sortSpreadsheet()));
 	connect(action_go_to_cell, SIGNAL(triggered()), this, SLOT(goToCell()));
 
 	connect(action_insert_column_left, SIGNAL(triggered()), this, SLOT(insertColumnLeft()));
 	connect(action_insert_column_right, SIGNAL(triggered()), this, SLOT(insertColumnRight()));
 	connect(action_remove_columns, SIGNAL(triggered()), this, SLOT(removeSelectedColumns()));
 	connect(action_clear_columns, SIGNAL(triggered()), this, SLOT(clearSelectedColumns()));
 	connect(action_set_as_none, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_x, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_y, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_z, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_xerr, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_xerr_minus, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_xerr_plus, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_yerr, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_yerr_minus, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_set_as_yerr_plus, SIGNAL(triggered()), this, SLOT(setSelectionAs()));
 	connect(action_reverse_columns, SIGNAL(triggered()), this, SLOT(reverseColumns()));
 	connect(action_drop_values, SIGNAL(triggered()), this, SLOT(dropColumnValues()));
 	connect(action_mask_values, SIGNAL(triggered()), this, SLOT(maskColumnValues()));
 // 	connect(action_join_columns, SIGNAL(triggered()), this, SLOT(joinColumns()));
 	connect(action_normalize_columns, SIGNAL(triggered()), this, SLOT(normalizeSelectedColumns()));
 	connect(action_normalize_selection, SIGNAL(triggered()), this, SLOT(normalizeSelection()));
 	connect(action_sort_columns, SIGNAL(triggered()), this, SLOT(sortSelectedColumns()));
 	connect(action_sort_asc_column, SIGNAL(triggered()), this, SLOT(sortColumnAscending()));
 	connect(action_sort_desc_column, SIGNAL(triggered()), this, SLOT(sortColumnDescending()));
 	connect(action_statistics_columns, SIGNAL(triggered()), this, SLOT(showColumnStatistics()));
 	connect(action_statistics_all_columns, SIGNAL(triggered()), this, SLOT(showAllColumnsStatistics()));
 
 	connect(action_insert_row_above, SIGNAL(triggered()), this, SLOT(insertRowAbove()));
 	connect(action_insert_row_below, SIGNAL(triggered()), this, SLOT(insertRowBelow()));
 	connect(action_remove_rows, SIGNAL(triggered()), this, SLOT(removeSelectedRows()));
 	connect(action_clear_rows, SIGNAL(triggered()), this, SLOT(clearSelectedRows()));
 	connect(action_statistics_rows, SIGNAL(triggered()), this, SLOT(showRowStatistics()));
 	connect(action_toggle_comments, SIGNAL(triggered()), this, SLOT(toggleComments()));
 
 	connect(action_plot_data_xycurve, SIGNAL(triggered()), this, SLOT(plotData()));
 	connect(action_plot_data_histogram, SIGNAL(triggered()), this, SLOT(plotData()));
 	connect(addDataReductionAction, SIGNAL(triggered()), SLOT(plotData()));
 	connect(addDifferentiationAction, SIGNAL(triggered()), SLOT(plotData()));
 	connect(addIntegrationAction, SIGNAL(triggered()), SLOT(plotData()));
 	connect(addInterpolationAction, SIGNAL(triggered()), SLOT(plotData()));
 	connect(addSmoothAction, SIGNAL(triggered()), SLOT(plotData()));
-	for (const auto& action: addFitAction)
+	for (const auto& action : addFitAction)
 		connect(action, SIGNAL(triggered()), SLOT(plotData()));
 	connect(addFourierFilterAction, SIGNAL(triggered()), SLOT(plotData()));
 }
 
 void SpreadsheetView::fillToolBar(QToolBar* toolBar) {
 	if (!m_readOnly) {
 		toolBar->addAction(action_insert_row_above);
 		toolBar->addAction(action_insert_row_below);
 		toolBar->addAction(action_remove_rows);
 	}
 	toolBar->addAction(action_statistics_rows);
 	toolBar->addSeparator();
 	if (!m_readOnly) {
 		toolBar->addAction(action_insert_column_left);
 		toolBar->addAction(action_insert_column_right);
 		toolBar->addAction(action_remove_columns);
 	}
 
 	toolBar->addAction(action_statistics_columns);
 	if (!m_readOnly) {
 		toolBar->addSeparator();
 		toolBar->addAction(action_sort_asc_column);
 		toolBar->addAction(action_sort_desc_column);
 	}
 }
 
 /*!
  * Populates the menu \c menu with the spreadsheet and spreadsheet view relevant actions.
  * The menu is used
  *   - as the context menu in SpreadsheetView
  *   - as the "spreadsheet menu" in the main menu-bar (called form MainWin)
  *   - as a part of the spreadsheet context menu in project explorer
  */
 void SpreadsheetView::createContextMenu(QMenu* menu) {
 	Q_ASSERT(menu);
 
 	checkSpreadsheetMenu();
 
 	QAction* firstAction = nullptr;
 	// 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);
 
 	if (m_spreadsheet->columnCount() > 0 && m_spreadsheet->rowCount() > 0) {
 		menu->insertMenu(firstAction, m_plotDataMenu);
 		menu->insertSeparator(firstAction);
 	}
 	menu->insertMenu(firstAction, m_selectionMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, action_select_all);
 	if (!m_readOnly) {
 		menu->insertAction(firstAction, action_clear_spreadsheet);
 		menu->insertAction(firstAction, action_clear_masks);
 		menu->insertAction(firstAction, action_sort_spreadsheet);
 		menu->insertSeparator(firstAction);
 	}
 
 	menu->insertAction(firstAction, action_go_to_cell);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, action_toggle_comments);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, action_statistics_all_columns);
 	menu->insertSeparator(firstAction);
 }
 
 /*!
  * adds column specific actions in SpreadsheetView to the context menu shown in the project explorer.
  */
 void SpreadsheetView::createColumnContextMenu(QMenu* menu) {
 	const Column* column = dynamic_cast<Column*>(QObject::sender());
 	if (!column)
 		return; //should never happen, since the sender is always a Column
 
 	const bool numeric = (column->columnMode() == AbstractColumn::Numeric) || (column->columnMode() == AbstractColumn::Integer);
 
 	if (numeric) {
 		QAction* firstAction = menu->actions().at(1);
 		menu->insertMenu(firstAction, m_columnSetAsMenu);
 
 		const bool hasValues = column->hasValues();
 
 		if (!m_readOnly) {
 			menu->insertSeparator(firstAction);
 			menu->insertMenu(firstAction, m_columnGenerateDataMenu);
 
 			menu->insertSeparator(firstAction);
 			menu->insertAction(firstAction, action_reverse_columns);
 			menu->insertAction(firstAction, action_drop_values);
 			menu->insertAction(firstAction, action_mask_values);
 			menu->insertAction(firstAction, action_normalize_columns);
 
 			menu->insertSeparator(firstAction);
 			menu->insertMenu(firstAction, m_columnSortMenu);
 			action_sort_asc_column->setVisible(true);
 			action_sort_desc_column->setVisible(true);
 			action_sort_columns->setVisible(false);
 
 			//in case no cells are available, deactivate the actions that only make sense in the presence of cells
 			const bool hasCells = m_spreadsheet->rowCount() > 0;
 			m_columnGenerateDataMenu->setEnabled(hasCells);
 
 			//in case no valid numerical values are available, deactivate the actions that only make sense in the presence of values
 			action_reverse_columns->setEnabled(hasValues);
 			action_drop_values->setEnabled(hasValues);
 			action_mask_values->setEnabled(hasValues);
 			action_normalize_columns->setEnabled(hasValues);
 			m_columnSortMenu->setEnabled(hasValues);
 		}
 
 		menu->insertSeparator(firstAction);
 		menu->insertAction(firstAction, action_statistics_columns);
 		action_statistics_columns->setEnabled(hasValues);
 	}
 }
 
 //SLOTS
 void SpreadsheetView::handleAspectAdded(const AbstractAspect* aspect) {
 	const Column* col = dynamic_cast<const Column*>(aspect);
 	if (!col || col->parentAspect() != m_spreadsheet)
 		return;
 
 	int index = m_spreadsheet->indexOfChild<Column>(col);
 	if (col->width() == 0)
 		m_tableView->resizeColumnToContents(index);
 	else
 		m_tableView->setColumnWidth(index, col->width());
 
 	connect(col, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createColumnContextMenu(QMenu*)));
 }
 
 void SpreadsheetView::handleAspectAboutToBeRemoved(const AbstractAspect* aspect) {
 	const Column* col = dynamic_cast<const Column*>(aspect);
 	if (!col || col->parentAspect() != m_spreadsheet)
 		return;
 
 	disconnect(col, nullptr, this, nullptr);
 }
 
 void SpreadsheetView::handleHorizontalSectionResized(int logicalIndex, int oldSize, int newSize) {
 	Q_UNUSED(logicalIndex);
 	Q_UNUSED(oldSize);
 
 	//save the new size in the column
 	Column* col = m_spreadsheet->child<Column>(logicalIndex);
 	col->setWidth(newSize);
 }
 
 void SpreadsheetView::goToCell(int row, int col) {
 	QModelIndex index = m_model->index(row, col);
 	m_tableView->scrollTo(index);
 	m_tableView->setCurrentIndex(index);
 }
 
 void SpreadsheetView::handleHorizontalSectionMoved(int index, int from, int to) {
 	Q_UNUSED(index);
 
 	static bool inside = false;
 	if (inside) return;
 
 	Q_ASSERT(index == from);
 
 	inside = true;
 	m_tableView->horizontalHeader()->moveSection(to, from);
 	inside = false;
 	m_spreadsheet->moveColumn(from, to);
 }
 
 //TODO Implement the "change of the column name"-mode  upon a double click
 void SpreadsheetView::handleHorizontalHeaderDoubleClicked(int index) {
 	Q_UNUSED(index);
 }
 
 /*!
   Returns whether comments are show currently or not.
 */
 bool SpreadsheetView::areCommentsShown() const {
 	return m_horizontalHeader->areCommentsShown();
 }
 
 /*!
   toggles the column comment in the horizontal header
 */
 void SpreadsheetView::toggleComments() {
 	showComments(!areCommentsShown());
 	//TODO
 	if (areCommentsShown())
 		action_toggle_comments->setText(i18n("Hide Comments"));
 	else
 		action_toggle_comments->setText(i18n("Show Comments"));
 }
 
 //! Shows (\c on=true) or hides (\c on=false) the column comments in the horizontal header
 void SpreadsheetView::showComments(bool on) {
 	m_horizontalHeader->showComments(on);
 }
 
 void SpreadsheetView::currentColumnChanged(const QModelIndex & current, const QModelIndex & previous) {
 	Q_UNUSED(previous);
 	int col = current.column();
 	if (col < 0 || col >= m_spreadsheet->columnCount())
 		return;
 }
 
 //TODO
 void SpreadsheetView::handleHeaderDataChanged(Qt::Orientation orientation, int first, int last) {
 	if (orientation != Qt::Horizontal) return;
 
 	QItemSelectionModel * sel_model = m_tableView->selectionModel();
 
 	int col = sel_model->currentIndex().column();
 	if (col < first || col > last) return;
 }
 
 /*!
   Returns the number of selected columns.
   If \c full is \c true, this function only returns the number of fully selected columns.
 */
 int SpreadsheetView::selectedColumnCount(bool full) const {
 	int count = 0;
 	const int cols = m_spreadsheet->columnCount();
 	for (int i=0; i<cols; i++)
 		if (isColumnSelected(i, full)) count++;
 	return count;
 }
 
 /*!
   Returns the number of (at least partly) selected columns with the plot designation \param pd.
  */
 int SpreadsheetView::selectedColumnCount(AbstractColumn::PlotDesignation pd) const{
 	int count = 0;
 	const int cols = m_spreadsheet->columnCount();
 	for (int i=0; i<cols; i++)
 		if ( isColumnSelected(i, false) && (m_spreadsheet->column(i)->plotDesignation() == pd) ) count++;
 
 	return count;
 }
 
 /*!
   Returns \c true if column \param col is selected, otherwise returns \c false.
   If \param full is \c true, this function only returns true if the whole column is selected.
 */
 bool SpreadsheetView::isColumnSelected(int col, bool full) const {
 	if (full)
 		return m_tableView->selectionModel()->isColumnSelected(col, QModelIndex());
 	else
 		return m_tableView->selectionModel()->columnIntersectsSelection(col, QModelIndex());
 }
 
 /*!
   Returns all selected columns.
   If \param full is true, this function only returns a column if the whole column is selected.
   */
 QVector<Column*> SpreadsheetView::selectedColumns(bool full) const {
 	QVector<Column*> columns;
 	const int cols = m_spreadsheet->columnCount();
 	for (int i=0; i<cols; i++)
 		if (isColumnSelected(i, full)) columns << m_spreadsheet->column(i);
 
 	return columns;
 }
 
 /*!
   Returns \c true if row \param row is selected; otherwise returns \c false
   If \param full is \c true, this function only returns \c true if the whole row is selected.
 */
 bool SpreadsheetView::isRowSelected(int row, bool full) const {
 	if (full)
 		return m_tableView->selectionModel()->isRowSelected(row, QModelIndex());
 	else
 		return m_tableView->selectionModel()->rowIntersectsSelection(row, QModelIndex());
 }
 
 /*!
   Return the index of the first selected column.
   If \param full is \c true, this function only looks for fully selected columns.
 */
 int SpreadsheetView::firstSelectedColumn(bool full) const {
 	const int cols = m_spreadsheet->columnCount();
 	for (int i=0; i<cols; i++) {
 		if (isColumnSelected(i, full))
 			return i;
 	}
 	return -1;
 }
 
 /*!
   Return the index of the last selected column.
   If \param full is \c true, this function only looks for fully selected columns.
   */
 int SpreadsheetView::lastSelectedColumn(bool full) const {
 	const int cols = m_spreadsheet->columnCount();
 	for (int i=cols-1; i>=0; i--)
 		if (isColumnSelected(i, full)) return i;
 
 	return -2;
 }
 
 /*!
   Return the index of the first selected row.
   If \param full is \c true, this function only looks for fully selected rows.
   */
 int SpreadsheetView::firstSelectedRow(bool full) const{
 	QModelIndexList indexes;
 	if (!full)
 		indexes = m_tableView->selectionModel()->selectedIndexes();
 	else
 		indexes = m_tableView->selectionModel()->selectedRows();
 
 	if (!indexes.empty())
 		return indexes.first().row();
 	else
 		return -1;
 }
 
 /*!
   Return the index of the last selected row.
   If \param full is \c true, this function only looks for fully selected rows.
   */
 int SpreadsheetView::lastSelectedRow(bool full) const {
 	QModelIndexList indexes;
 	if (!full)
 		indexes = m_tableView->selectionModel()->selectedIndexes();
 	else
 		indexes = m_tableView->selectionModel()->selectedRows();
 
 	if (!indexes.empty())
 		return indexes.last().row();
 	else
 		return -2;
 }
 
 /*!
   Return whether a cell is selected
  */
 bool SpreadsheetView::isCellSelected(int row, int col) const {
 	if (row < 0 || col < 0 || row >= m_spreadsheet->rowCount() || col >= m_spreadsheet->columnCount())
 		return false;
 
 	return m_tableView->selectionModel()->isSelected(m_model->index(row, col));
 }
 
 /*!
   Get the complete set of selected rows.
  */
 IntervalAttribute<bool> SpreadsheetView::selectedRows(bool full) const {
 	IntervalAttribute<bool> result;
 	const int rows = m_spreadsheet->rowCount();
 	for (int i=0; i<rows; i++)
 		if (isRowSelected(i, full))
 			result.setValue(i, true);
 	return result;
 }
 
 /*!
   Select/Deselect a cell.
  */
 void SpreadsheetView::setCellSelected(int row, int col, bool select) {
 	m_tableView->selectionModel()->select(m_model->index(row, col),
 	                                      select ? QItemSelectionModel::Select : QItemSelectionModel::Deselect);
 }
 
 /*!
   Select/Deselect a range of cells.
  */
 void SpreadsheetView::setCellsSelected(int first_row, int first_col, int last_row, int last_col, bool select) {
 	QModelIndex top_left = m_model->index(first_row, first_col);
 	QModelIndex bottom_right = m_model->index(last_row, last_col);
 	m_tableView->selectionModel()->select(QItemSelection(top_left, bottom_right),
 	                                      select ? QItemSelectionModel::SelectCurrent : QItemSelectionModel::Deselect);
 }
 
 /*!
   Determine the current cell (-1 if no cell is designated as the current).
  */
 void SpreadsheetView::getCurrentCell(int* row, int* col) const {
 	QModelIndex index = m_tableView->selectionModel()->currentIndex();
 	if (index.isValid())	{
 		*row = index.row();
 		*col = index.column();
 	} else {
 		*row = -1;
 		*col = -1;
 	}
 }
 
 bool SpreadsheetView::eventFilter(QObject* watched, QEvent* event) {
 	if (event->type() == QEvent::ContextMenu) {
 		QContextMenuEvent* cm_event = static_cast<QContextMenuEvent*>(event);
 		const QPoint global_pos = cm_event->globalPos();
 		if (watched == m_tableView->verticalHeader()) {
 			bool onlyNumeric = true;
 			for (int i = 0; i < m_spreadsheet->columnCount(); ++i) {
 				if (m_spreadsheet->column(i)->columnMode() != AbstractColumn::Numeric) {
 					onlyNumeric = false;
 					break;
 				}
 			}
 			action_statistics_rows->setVisible(onlyNumeric);
 			m_rowMenu->exec(global_pos);
 		} else if (watched == m_horizontalHeader) {
 			const int col = m_horizontalHeader->logicalIndexAt(cm_event->pos());
 			if (!isColumnSelected(col, true)) {
 				QItemSelectionModel* sel_model = m_tableView->selectionModel();
 				sel_model->clearSelection();
 				sel_model->select(QItemSelection(m_model->index(0, col, QModelIndex()),
 												m_model->index(m_model->rowCount()-1, col, QModelIndex())),
 								QItemSelectionModel::Select);
 			}
 
 			if (selectedColumns().size()==1) {
 				action_sort_columns->setVisible(false);
 				action_sort_asc_column->setVisible(true);
 				action_sort_desc_column->setVisible(true);
 			} else {
 				action_sort_columns->setVisible(true);
 				action_sort_asc_column->setVisible(false);
 				action_sort_desc_column->setVisible(false);
 			}
 
 			//check whether we have non-numeric columns selected and deactivate actions for numeric columns
 			bool numeric = true;
 			bool plottable = true;
 			for(const Column* col : selectedColumns()) {
 				if ( !(col->columnMode() == AbstractColumn::Numeric || col->columnMode() == AbstractColumn::Integer) ) {
 					if (col->columnMode() != AbstractColumn::DateTime)
 						plottable = false;
 
 					numeric = false;
 					break;
 				}
 			}
 
 			m_plotDataMenu->setEnabled(plottable);
 			m_analyzePlotMenu->setEnabled(numeric);
 			m_columnSetAsMenu->setEnabled(numeric);
 			if (!m_readOnly) {
 				m_columnGenerateDataMenu->setEnabled(numeric);
 				action_reverse_columns->setEnabled(numeric);
 				action_drop_values->setEnabled(numeric);
 				action_mask_values->setEnabled(numeric);
 				action_normalize_columns->setEnabled(numeric);
 				m_columnSortMenu->setEnabled(numeric);
 			}
 			action_statistics_columns->setEnabled(numeric);
 
 			if (numeric) {
 				bool hasValues = false;
 				for (const Column* col : selectedColumns()) {
 					if (col->hasValues()) {
 						hasValues = true;
 						break;
 					}
 				}
 
 				if (!m_readOnly) {
 					//in case no cells are available, deactivate the actions that only make sense in the presence of cells
 					const bool hasCells = m_spreadsheet->rowCount() > 0;
 					m_columnGenerateDataMenu->setEnabled(hasCells);
 
 					//in case no valid numerical values are available, deactivate the actions that only make sense in the presence of values
 					action_reverse_columns->setEnabled(hasValues);
 					action_drop_values->setEnabled(hasValues);
 					action_mask_values->setEnabled(hasValues);
 					action_normalize_columns->setEnabled(hasValues);
 					m_columnSortMenu->setEnabled(hasValues);
 				}
 
 				action_statistics_columns->setEnabled(hasValues);
 			}
 
 			m_columnMenu->exec(global_pos);
 		} else if (watched == this) {
 			checkSpreadsheetMenu();
 			m_spreadsheetMenu->exec(global_pos);
 		}
 
 		return true;
 	} else if (event->type() == QEvent::KeyPress) {
 		QKeyEvent* key_event = static_cast<QKeyEvent*>(event);
 		if (key_event->matches(QKeySequence::Copy))
 			copySelection();
 		else if (key_event->matches(QKeySequence::Paste))
 			pasteIntoSelection();
 	}
 
 	return QWidget::eventFilter(watched, event);
 }
 
 /*!
  * disables cell data relevant actions in the spreadsheet menu if there're no cells available
  */
 void SpreadsheetView::checkSpreadsheetMenu() {
 	const bool cellsAvail = m_spreadsheet->columnCount()>0 && m_spreadsheet->rowCount()>0;
 	m_plotDataMenu->setEnabled(cellsAvail);
 	m_selectionMenu->setEnabled(cellsAvail);
 	action_select_all->setEnabled(cellsAvail);
 	action_clear_spreadsheet->setEnabled(cellsAvail);
 	action_clear_masks->setEnabled(cellsAvail);
 	action_sort_spreadsheet->setEnabled(cellsAvail);
 	action_go_to_cell->setEnabled(cellsAvail);
 	action_statistics_all_columns->setEnabled(cellsAvail);
 }
 
 bool SpreadsheetView::formulaModeActive() const {
 	return m_model->formulaModeActive();
 }
 
 void SpreadsheetView::activateFormulaMode(bool on) {
 	m_model->activateFormulaMode(on);
 }
 
 void SpreadsheetView::goToNextColumn() {
 	if (m_spreadsheet->columnCount() == 0) return;
 
 	QModelIndex idx = m_tableView->currentIndex();
 	int col = idx.column()+1;
 	if (col >= m_spreadsheet->columnCount())
 		col = 0;
 
 	m_tableView->setCurrentIndex(idx.sibling(idx.row(), col));
 }
 
 void SpreadsheetView::goToPreviousColumn() {
 	if (m_spreadsheet->columnCount() == 0)
 		return;
 
 	QModelIndex idx = m_tableView->currentIndex();
 	int col = idx.column()-1;
 	if (col < 0)
 		col = m_spreadsheet->columnCount()-1;
 
 	m_tableView->setCurrentIndex(idx.sibling(idx.row(), col));
 }
 
 void SpreadsheetView::cutSelection() {
 	int first = firstSelectedRow();
 	if ( first < 0 )
 		return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: cut selected cells", m_spreadsheet->name()));
 	copySelection();
 	clearSelectedCells();
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::copySelection() {
 	PERFTRACE("copy selected cells");
 	const int first_col = firstSelectedColumn();
 	if (first_col == -1) return;
 	const int last_col = lastSelectedColumn();
 	if (last_col == -2) return;
 	const int first_row = firstSelectedRow();
 	if (first_row == -1)	return;
 	const int last_row = lastSelectedRow();
 	if (last_row == -2) return;
 	const int cols = last_col - first_col + 1;
 	const int rows = last_row - first_row + 1;
 
 	WAIT_CURSOR;
 	QString output_str;
 
 	QVector<Column*> columns;
 	QVector<char> formats;
 	for (int c = 0; c < cols; c++) {
 		Column* col = m_spreadsheet->column(first_col + c);
 		columns << col;
 		const Double2StringFilter* out_fltr = static_cast<Double2StringFilter*>(col->outputFilter());
 		formats << out_fltr->numericFormat();
 	}
 
 	QLocale locale;
 	for (int r = 0; r < rows; r++) {
 		for (int c = 0; c < cols; c++) {
 			const Column* col_ptr = columns.at(c);
 			if (isCellSelected(first_row + r, first_col + c)) {
 // 				if (formulaModeActive())
 // 					output_str += col_ptr->formula(first_row + r);
 // 				else
 				if (col_ptr->columnMode() == AbstractColumn::Numeric)
 					output_str += locale.toString(col_ptr->valueAt(first_row + r), formats.at(c), 16); // copy with max. precision
 				else
 					output_str += col_ptr->asStringColumn()->textAt(first_row + r);
 			}
 			if (c < cols-1)
 				output_str += '\t';
 		}
 		if (r < rows-1)
 			output_str += '\n';
 	}
 
 	QApplication::clipboard()->setText(output_str);
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::pasteIntoSelection() {
 	if (m_spreadsheet->columnCount() < 1 || m_spreadsheet->rowCount() < 1)
 		return;
 
 	const QMimeData* mime_data = QApplication::clipboard()->mimeData();
 	if (!mime_data->hasFormat("text/plain"))
 		return;
 
 	PERFTRACE("paste selected cells");
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: paste from clipboard", m_spreadsheet->name()));
 
 	int first_col = firstSelectedColumn();
 	int last_col = lastSelectedColumn();
 	int first_row = firstSelectedRow();
 	int last_row = lastSelectedRow();
 	int input_row_count = 0;
 	int input_col_count = 0;
 
 	QString input_str = QString(mime_data->data("text/plain")).trimmed();
 	QVector<QStringList> cellTexts;
 	QStringList input_rows(input_str.split(QLatin1Char('\n')));
 	input_row_count = input_rows.count();
 	input_col_count = 0;
 	for (int i=0; i<input_row_count; i++) {
 		cellTexts.append(input_rows.at(i).split(QRegExp(QLatin1String("\\s+"))));
 		if (cellTexts.at(i).count() > input_col_count)
 			input_col_count = cellTexts.at(i).count();
 	}
 
 	if ( (first_col == -1 || first_row == -1) || (last_row == first_row && last_col == first_col) ) {
 		// if there is no selection or only one cell selected, the
 		// selection will be expanded to the needed size from the current cell
 		int current_row, current_col;
 		getCurrentCell(&current_row, &current_col);
 		if (current_row == -1) current_row = 0;
 		if (current_col == -1) current_col = 0;
 		setCellSelected(current_row, current_col);
 		first_col = current_col;
 		first_row = current_row;
 		last_row = first_row + input_row_count -1;
 		last_col = first_col + input_col_count -1;
 
 		//add columns if necessary
 		const int columnCount = m_spreadsheet->columnCount();
 		if (last_col >= columnCount) {
 			for (int c = 0; c < last_col - (columnCount - 1); ++c) {
 				const int curCol = columnCount - 1 + c;
 				//first non-empty value in the column to paste determines the column mode/type of the new column to be added
 				QString nonEmptyValue;
-				for (auto r: cellTexts) {
+				for (auto r : cellTexts) {
 					if (!r.at(curCol).isEmpty()) {
 						nonEmptyValue = r.at(curCol);
 						break;
 					}
 				}
 				const AbstractColumn::ColumnMode mode = AbstractFileFilter::columnMode(nonEmptyValue,
 														QLatin1String("yyyy-dd-MM hh:mm:ss:zzz"), QLocale::AnyLanguage);
 				Column* new_col = new Column(QString::number(curCol), mode);
 				new_col->setPlotDesignation(AbstractColumn::Y);
 				new_col->insertRows(0, m_spreadsheet->rowCount());
 				m_spreadsheet->addChild(new_col);
 			}
 		}
 
 		//add rows if necessary
 		if (last_row >= m_spreadsheet->rowCount())
 			m_spreadsheet->appendRows(last_row + 1 - m_spreadsheet->rowCount());
 
 		// select the rectangle to be pasted in
 		setCellsSelected(first_row, first_col, last_row, last_col);
 	}
 
 	const int rows = last_row - first_row + 1;
 	const int cols = last_col - first_col + 1;
 	QLocale locale;
 	for (int c = 0; c < cols && c < input_col_count; c++) {
 		Column* col = m_spreadsheet->column(first_col + c);
 		col->setSuppressDataChangedSignal(true);
 		if (col->columnMode() == AbstractColumn::Numeric) {
 			if (rows == m_spreadsheet->rowCount() && rows == cellTexts.size()) {
 				QVector<double> new_data(rows);
 				for (int r = 0; r < rows; ++r)
 					new_data[r] = locale.toDouble(cellTexts.at(r).at(c));
 				col->replaceValues(0, new_data);
 			} else {
 				for (int r = 0; r < rows && r < input_row_count; r++) {
 					if ( isCellSelected(first_row + r, first_col + c) && (c < cellTexts.at(r).count()) ) {
 						if (!cellTexts.at(r).at(c).isEmpty())
 							col->setValueAt(first_row + r, locale.toDouble(cellTexts.at(r).at(c)));
 						else
 							col->setValueAt(first_row + r, NAN);
 					}
 				}
 			}
 		} else {
 			for (int r = 0; r < rows && r < input_row_count; r++) {
 				if (isCellSelected(first_row + r, first_col + c) && (c < cellTexts.at(r).count()) ) {
 // 					if (formulaModeActive())
 // 						col->setFormula(first_row + r, cellTexts.at(r).at(c));
 // 					else
 					col->asStringColumn()->setTextAt(first_row + r, cellTexts.at(r).at(c));
 				}
 			}
 		}
 
 		col->setSuppressDataChangedSignal(false);
 		col->setChanged();
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::maskSelection() {
 	int first = firstSelectedRow();
 	if ( first < 0 ) return;
 	int last = lastSelectedRow();
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: mask selected cells", m_spreadsheet->name()));
 	for (auto* column : selectedColumns()) {
 		int col = m_spreadsheet->indexOfChild<Column>(column);
 		for (int row=first; row<=last; row++)
 			if (isCellSelected(row, col)) column->setMasked(row);
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::unmaskSelection() {
 	int first = firstSelectedRow();
 	if ( first < 0 ) return;
 	int last = lastSelectedRow();
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: unmask selected cells", m_spreadsheet->name()));
 	for (auto* column : selectedColumns()) {
 		int col = m_spreadsheet->indexOfChild<Column>(column);
 		for (int row=first; row<=last; row++)
 			if (isCellSelected(row, col)) column->setMasked(row, false);
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::plotData() {
 	const QAction* action = dynamic_cast<const QAction*>(QObject::sender());
 	PlotDataDialog::PlotType type = PlotDataDialog::PlotXYCurve;
 	if (action == action_plot_data_xycurve || action == action_plot_data_histogram)
 		type = (PlotDataDialog::PlotType)action->data().toInt();
 
 	PlotDataDialog* dlg = new PlotDataDialog(m_spreadsheet, type);
 
 	if ( action != action_plot_data_xycurve && action != action_plot_data_histogram ) {
 		PlotDataDialog::AnalysisAction type = (PlotDataDialog::AnalysisAction)action->data().toInt();
 		dlg->setAnalysisAction(type);
 	}
 
 	dlg->exec();
 }
 
 void SpreadsheetView::fillSelectedCellsWithRowNumbers() {
 	if (selectedColumnCount() < 1) return;
 	int first = firstSelectedRow();
 	if ( first < 0 ) return;
 	int last = lastSelectedRow();
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: fill cells with row numbers", m_spreadsheet->name()));
-	for (auto* col_ptr: selectedColumns()) {
+	for (auto* col_ptr : selectedColumns()) {
 		int col = m_spreadsheet->indexOfChild<Column>(col_ptr);
 		col_ptr->setSuppressDataChangedSignal(true);
 		switch (col_ptr->columnMode()) {
 		case AbstractColumn::Numeric: {
 				QVector<double> results(last-first+1);
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results[row-first] = row + 1;
 					else
 						results[row-first] = col_ptr->valueAt(row);
 				col_ptr->replaceValues(first, results);
 				break;
 			}
 		case AbstractColumn::Integer: {
 				QVector<int> results(last-first+1);
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results[row-first] = row + 1;
 					else
 						results[row-first] = col_ptr->integerAt(row);
 				col_ptr->replaceInteger(first, results);
 				break;
 			}
 		case AbstractColumn::Text: {
 				QVector<QString> results;
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results << QString::number(row+1);
 					else
 						results << col_ptr->textAt(row);
 				col_ptr->replaceTexts(first, results);
 				break;
 			}
 		//TODO: handle other modes
 		case AbstractColumn::DateTime:
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 			break;
 		}
 
 		col_ptr->setSuppressDataChangedSignal(false);
 		col_ptr->setChanged();
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::fillWithRowNumbers() {
 	if (selectedColumnCount() < 1) return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18np("%1: fill column with row numbers",
 	                                "%1: fill columns with row numbers",
 	                                m_spreadsheet->name(),
 	                                selectedColumnCount()));
 
 	const int rows = m_spreadsheet->rowCount();
 
 	QVector<double> double_data(rows);
 	QVector<int> int_data(rows);
 	for (int i = 0; i < rows; ++i)
 		double_data[i] = int_data[i] = i+1;
 
-	for (auto* col: selectedColumns()) {
+	for (auto* col : selectedColumns()) {
 		switch (col->columnMode()) {
 		case AbstractColumn::Numeric:
 			col->replaceValues(0, double_data);
 			break;
 		case AbstractColumn::Integer:
 			col->replaceInteger(0, int_data);
 			break;
 		case AbstractColumn::Text:
 		case AbstractColumn::DateTime:
 		case AbstractColumn::Day:
 		case AbstractColumn::Month:
 			break;
 		}
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 //TODO: this function is not used currently.
 void SpreadsheetView::fillSelectedCellsWithRandomNumbers() {
 	if (selectedColumnCount() < 1) return;
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: fill cells with random values", m_spreadsheet->name()));
 	qsrand(QTime::currentTime().msec());
-	for (auto* col_ptr: selectedColumns()) {
+	for (auto* col_ptr : selectedColumns()) {
 		int col = m_spreadsheet->indexOfChild<Column>(col_ptr);
 		col_ptr->setSuppressDataChangedSignal(true);
 		switch (col_ptr->columnMode()) {
 		case AbstractColumn::Numeric: {
 				QVector<double> results(last-first+1);
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results[row-first] = double(qrand())/double(RAND_MAX);
 					else
 						results[row-first] = col_ptr->valueAt(row);
 				col_ptr->replaceValues(first, results);
 				break;
 			}
 		case AbstractColumn::Integer: {
 				QVector<int> results(last-first+1);
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results[row-first] = qrand();
 					else
 						results[row-first] = col_ptr->integerAt(row);
 				col_ptr->replaceInteger(first, results);
 				break;
 			}
 		case AbstractColumn::Text: {
 				QVector<QString> results;
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results << QString::number(double(qrand())/double(RAND_MAX));
 					else
 						results << col_ptr->textAt(row);
 				col_ptr->replaceTexts(first, results);
 				break;
 			}
 		case AbstractColumn::DateTime:
 		case AbstractColumn::Month:
 		case AbstractColumn::Day: {
 				QVector<QDateTime> results;
 				QDate earliestDate(1,1,1);
 				QDate latestDate(2999,12,31);
 				QTime midnight(0,0,0,0);
 				for (int row = first; row <= last; row++)
 					if (isCellSelected(row, col))
 						results << QDateTime( earliestDate.addDays(((double)qrand())*((double)earliestDate.daysTo(latestDate))/((double)RAND_MAX)), midnight.addMSecs(((qint64)qrand())*1000*60*60*24/RAND_MAX));
 					else
 						results << col_ptr->dateTimeAt(row);
 				col_ptr->replaceDateTimes(first, results);
 				break;
 			}
 		}
 
 		col_ptr->setSuppressDataChangedSignal(false);
 		col_ptr->setChanged();
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::fillWithRandomValues() {
 	if (selectedColumnCount() < 1) return;
 	RandomValuesDialog* dlg = new RandomValuesDialog(m_spreadsheet);
 	dlg->setColumns(selectedColumns());
 	dlg->exec();
 }
 
 void SpreadsheetView::fillWithEquidistantValues() {
 	if (selectedColumnCount() < 1) return;
 	EquidistantValuesDialog* dlg = new EquidistantValuesDialog(m_spreadsheet);
 	dlg->setColumns(selectedColumns());
 	dlg->exec();
 }
 
 void SpreadsheetView::fillWithFunctionValues() {
 	if (selectedColumnCount() < 1) return;
 	FunctionValuesDialog* dlg = new FunctionValuesDialog(m_spreadsheet);
 	dlg->setColumns(selectedColumns());
 	dlg->exec();
 }
 
 void SpreadsheetView::fillSelectedCellsWithConstValues() {
 	if (selectedColumnCount() < 1) return;
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	if (first < 0)
 		return;
 
 	bool doubleOk = false;
 	bool intOk = false;
 	bool stringOk = false;
 	double doubleValue = 0;
 	int intValue = 0;
 	QString stringValue;
 
 	m_spreadsheet->beginMacro(i18n("%1: fill cells with const values", m_spreadsheet->name()));
-	for (auto* col_ptr: selectedColumns()) {
+	for (auto* col_ptr : selectedColumns()) {
 		int col = m_spreadsheet->indexOfChild<Column>(col_ptr);
 		col_ptr->setSuppressDataChangedSignal(true);
 		switch (col_ptr->columnMode()) {
 		case AbstractColumn::Numeric:
 			if (!doubleOk)
 				doubleValue = QInputDialog::getDouble(this, i18n("Fill the selection with constant value"),
 				                                      i18n("Value"), 0, -2147483647, 2147483647, 6, &doubleOk);
 			if (doubleOk) {
 				WAIT_CURSOR;
 				QVector<double> results(last-first+1);
 				for (int row = first; row <= last; row++) {
 					if (isCellSelected(row, col))
 						results[row-first] = doubleValue;
 					else
 						results[row-first] = col_ptr->valueAt(row);
 				}
 				col_ptr->replaceValues(first, results);
 				RESET_CURSOR;
 			}
 			break;
 		case AbstractColumn::Integer:
 			if (!intOk)
 				intValue = QInputDialog::getInt(this, i18n("Fill the selection with constant value"),
 				                                i18n("Value"), 0, -2147483647, 2147483647, 1, &intOk);
 			if (intOk) {
 				WAIT_CURSOR;
 				QVector<int> results(last-first+1);
 				for (int row = first; row <= last; row++) {
 					if (isCellSelected(row, col))
 						results[row-first] = intValue;
 					else
 						results[row-first] = col_ptr->integerAt(row);
 				}
 				col_ptr->replaceInteger(first, results);
 				RESET_CURSOR;
 			}
 			break;
 		case AbstractColumn::Text:
 			if (!stringOk)
 				stringValue = QInputDialog::getText(this, i18n("Fill the selection with constant value"),
 				                                    i18n("Value"), QLineEdit::Normal, nullptr, &stringOk);
 			if (stringOk && !stringValue.isEmpty()) {
 				WAIT_CURSOR;
 				QVector<QString> results;
 				for (int row = first; row <= last; row++) {
 					if (isCellSelected(row, col))
 						results << stringValue;
 					else
 						results << col_ptr->textAt(row);
 				}
 				col_ptr->replaceTexts(first, results);
 				RESET_CURSOR;
 			}
 			break;
 		//TODO: handle other modes
 		case AbstractColumn::DateTime:
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 			break;
 		}
 
 		col_ptr->setSuppressDataChangedSignal(false);
 		col_ptr->setChanged();
 	}
 	m_spreadsheet->endMacro();
 }
 
 /*!
     Open the sort dialog for all columns.
 */
 void SpreadsheetView::sortSpreadsheet() {
 	sortDialog(m_spreadsheet->children<Column>());
 }
 
 /*!
   Insert an empty column left to the firt selected column
 */
 void SpreadsheetView::insertColumnLeft() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: insert empty column", m_spreadsheet->name()));
 
 	Column* newCol = new Column("1", AbstractColumn::Numeric);
 	newCol->setPlotDesignation(AbstractColumn::Y);
 	const int first = firstSelectedColumn();
 
 	if (first >= 0) {
 		//determine the first selected column
 		Column* firstCol = m_spreadsheet->child<Column>(first);
 
 		//resize the new column and insert it before the first selected column
 		newCol->insertRows(0, m_spreadsheet->rowCount());
 		m_spreadsheet->insertChildBefore(newCol, firstCol);
 	} else {
 		if (m_spreadsheet->columnCount()>0) {
 			//columns available but no columns selected -> prepend the new column at the very beginning
 			Column* firstCol = m_spreadsheet->child<Column>(0);
 			newCol->insertRows(0, m_spreadsheet->rowCount());
 			m_spreadsheet->insertChildBefore(newCol, firstCol);
 		} else {
 			//no columns available anymore -> resize the spreadsheet and the new column to the default size
 			KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Spreadsheet"));
 			const int rows = group.readEntry(QLatin1String("RowCount"), 100);
 			m_spreadsheet->setRowCount(rows);
 			newCol->insertRows(0, rows);
 
 			//add/append a new column
 			m_spreadsheet->addChild(newCol);
 		}
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 /*!
   Insert an empty column right to the last selected column
 */
 void SpreadsheetView::insertColumnRight() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: insert empty column", m_spreadsheet->name()));
 
 	Column* newCol = new Column("1", AbstractColumn::Numeric);
 	newCol->setPlotDesignation(AbstractColumn::Y);
 	const int last = lastSelectedColumn();
 
 	if (last >= 0) {
 		newCol->insertRows(0, m_spreadsheet->rowCount());
 		if (last < m_spreadsheet->columnCount() - 1) {
 			//determine the column next to the last selected column
 			Column* nextCol = m_spreadsheet->child<Column>(last + 1);
 
 			//insert the new column before the column next to the last selected column
 			m_spreadsheet->insertChildBefore(newCol, nextCol);
 		} else {
 			//last column selected, no next column available -> add/append a new column
 			m_spreadsheet->addChild(newCol);
 		}
 	} else {
 		if (m_spreadsheet->columnCount()>0) {
 			//columns available but no columns selected -> append the new column at the very end
 			newCol->insertRows(0, m_spreadsheet->rowCount());
 			m_spreadsheet->addChild(newCol);
 		} else {
 			//no columns available anymore -> resize the spreadsheet and the new column to the default size
 			KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Spreadsheet"));
 			const int rows = group.readEntry(QLatin1String("RowCount"), 100);
 			newCol->insertRows(0, rows);
 			m_spreadsheet->setRowCount(rows);
 
 			 //add/append a new column
 			m_spreadsheet->addChild(newCol);
 		}
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::removeSelectedColumns() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: remove selected columns", m_spreadsheet->name()));
 
 	for (auto* column : selectedColumns())
 		m_spreadsheet->removeChild(column);
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::clearSelectedColumns() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: clear selected columns", m_spreadsheet->name()));
 
 	if (formulaModeActive()) {
-		for (auto* col: selectedColumns()) {
+		for (auto* col : selectedColumns()) {
 			col->setSuppressDataChangedSignal(true);
 			col->clearFormulas();
 			col->setSuppressDataChangedSignal(false);
 			col->setChanged();
 		}
 	} else {
-		for (auto* col: selectedColumns()) {
+		for (auto* col : selectedColumns()) {
 			col->setSuppressDataChangedSignal(true);
 			col->clear();
 			col->setSuppressDataChangedSignal(false);
 			col->setChanged();
 		}
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::setSelectionAs() {
 	QVector<Column*> columns = selectedColumns();
 	if (!columns.size())
 		return;
 
 	m_spreadsheet->beginMacro(i18n("%1: set plot designation", m_spreadsheet->name()));
 
 	QAction* action = dynamic_cast<QAction*>(QObject::sender());
 	if (!action)
 		return;
 
 	AbstractColumn::PlotDesignation pd = (AbstractColumn::PlotDesignation)action->data().toInt();
-	for (auto* col: columns)
+	for (auto* col : columns)
 		col->setPlotDesignation(pd);
 
 	m_spreadsheet->endMacro();
 }
 
 void SpreadsheetView::reverseColumns() {
 	WAIT_CURSOR;
 	QVector<Column*> cols = selectedColumns();
 	m_spreadsheet->beginMacro(i18np("%1: reverse column", "%1: reverse columns",
 	                                m_spreadsheet->name(), cols.size()));
-	for (auto* col: cols) {
+	for (auto* col : cols) {
 		if (col->columnMode() != AbstractColumn::Numeric)
 			continue;
 
 		QVector<double>* data = static_cast<QVector<double>* >(col->data());
 		QVector<double> new_data(*data);
 		std::reverse(new_data.begin(), new_data.end());
 		col->replaceValues(0, new_data);
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::dropColumnValues() {
 	if (selectedColumnCount() < 1) return;
 	DropValuesDialog* dlg = new DropValuesDialog(m_spreadsheet);
 	dlg->setColumns(selectedColumns());
 	dlg->exec();
 }
 
 void SpreadsheetView::maskColumnValues() {
 	if (selectedColumnCount() < 1) return;
 	DropValuesDialog* dlg = new DropValuesDialog(m_spreadsheet, true);
 	dlg->setColumns(selectedColumns());
 	dlg->exec();
 }
 
 void SpreadsheetView::joinColumns() {
 	//TODO
 }
 
 void SpreadsheetView::normalizeSelectedColumns() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: normalize columns", m_spreadsheet->name()));
 	for (auto* col : selectedColumns()) {
 		if (col->columnMode() == AbstractColumn::Numeric) {
 			col->setSuppressDataChangedSignal(true);
 			double max = col->maximum();
 			if (max != 0.0) {// avoid division by zero
 				for (int row=0; row<col->rowCount(); row++)
 					col->setValueAt(row, col->valueAt(row) / max);
 			}
 			col->setSuppressDataChangedSignal(false);
 			col->setChanged();
 		}
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::normalizeSelection() {
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: normalize selection", m_spreadsheet->name()));
 	double max = 0.0;
 	for (int col = firstSelectedColumn(); col <= lastSelectedColumn(); col++)
 		if (m_spreadsheet->column(col)->columnMode() == AbstractColumn::Numeric)
 			for (int row = 0; row < m_spreadsheet->rowCount(); row++) {
 				if (isCellSelected(row, col) && m_spreadsheet->column(col)->valueAt(row) > max)
 					max = m_spreadsheet->column(col)->valueAt(row);
 			}
 
 	if (max != 0.0) { // avoid division by zero
 		//TODO setSuppressDataChangedSignal
 		for (int col = firstSelectedColumn(); col <= lastSelectedColumn(); col++)
 			if (m_spreadsheet->column(col)->columnMode() == AbstractColumn::Numeric)
 				for (int row = 0; row < m_spreadsheet->rowCount(); row++) {
 					if (isCellSelected(row, col))
 						m_spreadsheet->column(col)->setValueAt(row, m_spreadsheet->column(col)->valueAt(row) / max);
 				}
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::sortSelectedColumns() {
 	sortDialog(selectedColumns());
 }
 
 
 void SpreadsheetView::showAllColumnsStatistics() {
 	showColumnStatistics(true);
 }
 
 void SpreadsheetView::showColumnStatistics(bool forAll) {
 	QString dlgTitle(m_spreadsheet->name() + " column statistics");
 	StatisticsDialog* dlg = new StatisticsDialog(dlgTitle);
 	QVector<Column*> columns;
 
 	if (!forAll)
 		dlg->setColumns(selectedColumns());
 	else if (forAll) {
 		for (int col = 0; col < m_spreadsheet->columnCount(); ++col) {
 			if (m_spreadsheet->column(col)->columnMode() == AbstractColumn::Numeric)
 				columns << m_spreadsheet->column(col);
 		}
 		dlg->setColumns(columns);
 	}
 	if (dlg->exec() == QDialog::Accepted) {
 		if (forAll)
 			columns.clear();
 	}
 }
 
 void SpreadsheetView::showRowStatistics() {
 	QString dlgTitle(m_spreadsheet->name() + " row statistics");
 	StatisticsDialog* dlg = new StatisticsDialog(dlgTitle);
 
 	QVector<Column*> columns;
 	for (int i = 0; i < m_spreadsheet->rowCount(); ++i) {
 		if (isRowSelected(i)) {
 			QVector<double> rowValues;
 			for (int j = 0; j < m_spreadsheet->columnCount(); ++j)
 				rowValues << m_spreadsheet->column(j)->valueAt(i);
 			columns << new Column(QString::number(i+1), rowValues);
 		}
 	}
 	dlg->setColumns(columns);
 
 	if (dlg->exec() == QDialog::Accepted) {
 		qDeleteAll(columns);
 		columns.clear();
 	}
 }
 
 /*!
   Insert an empty row above(=before) the first selected row
 */
 void SpreadsheetView::insertRowAbove() {
 	int first = firstSelectedRow();
 	if (first < 0)
 		return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: insert empty rows", m_spreadsheet->name()));
 	m_spreadsheet->insertRows(first, 1);
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 /*!
   Insert an empty row below the last selected row
 */
 void SpreadsheetView::insertRowBelow() {
 	int last = lastSelectedRow();
 	if (last < 0)
 		return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: insert empty rows", m_spreadsheet->name()));
 
 	if (last < m_spreadsheet->rowCount() -1)
 		m_spreadsheet->insertRows(last + 1, 1); //insert before the next to the last selected row
 	else
 		m_spreadsheet->appendRow(); //append one row at the end
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::removeSelectedRows() {
 	if (firstSelectedRow() < 0) return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: remove selected rows", m_spreadsheet->name()));
 	//TODO setSuppressDataChangedSignal
-	for (const auto& i: selectedRows().intervals())
+	for (const auto& i : selectedRows().intervals())
 		m_spreadsheet->removeRows(i.start(), i.size());
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::clearSelectedRows() {
 	if (firstSelectedRow() < 0) return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: clear selected rows", m_spreadsheet->name()));
-	for (auto* col: selectedColumns()) {
+	for (auto* col : selectedColumns()) {
 		col->setSuppressDataChangedSignal(true);
 		if (formulaModeActive()) {
-			for (const auto& i: selectedRows().intervals())
+			for (const auto& i : selectedRows().intervals())
 				col->setFormula(i, "");
 		} else {
-			for (const auto& i: selectedRows().intervals()) {
+			for (const auto& i : selectedRows().intervals()) {
 				if (i.end() == col->rowCount()-1)
 					col->removeRows(i.start(), i.size());
 				else {
 					QVector<QString> empties;
 					for (int j = 0; j < i.size(); j++)
 						empties << QString();
 					col->asStringColumn()->replaceTexts(i.start(), empties);
 				}
 			}
 		}
 
 		col->setSuppressDataChangedSignal(false);
 		col->setChanged();
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 
 	//selected rows were deleted but the view selection is still in place -> reset the selection in the view
 	m_tableView->clearSelection();
 }
 
 void SpreadsheetView::clearSelectedCells() {
 	int first = firstSelectedRow();
 	int last = lastSelectedRow();
 	if (first < 0) return;
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: clear selected cells", m_spreadsheet->name()));
 	for (auto* column : selectedColumns()) {
 		column->setSuppressDataChangedSignal(true);
 		if (formulaModeActive()) {
 			int col = m_spreadsheet->indexOfChild<Column>(column);
 			for (int row = last; row >= first; row--)
 				if (isCellSelected(row, col))
 					column->setFormula(row, "");
 		} else {
 			int col = m_spreadsheet->indexOfChild<Column>(column);
 			for (int row = last; row >= first; row--)
 				if (isCellSelected(row, col)) {
 					if (row < column->rowCount())
 						column->asStringColumn()->setTextAt(row, QString());
 				}
 		}
 		column->setSuppressDataChangedSignal(false);
 		column->setChanged();
 	}
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::goToCell() {
 	bool ok;
 
 	int col = QInputDialog::getInt(nullptr, i18n("Go to Cell"), i18n("Enter column"), 1, 1, m_spreadsheet->columnCount(), 1, &ok);
 	if (!ok) return;
 
 	int row = QInputDialog::getInt(nullptr, i18n("Go to Cell"), i18n("Enter row"), 1, 1, m_spreadsheet->rowCount(), 1, &ok);
 	if (!ok) return;
 
 	goToCell(row-1, col-1);
 }
 
 //! Open the sort dialog for the given columns
 void SpreadsheetView::sortDialog(QVector<Column*> cols) {
 	if (cols.isEmpty()) return;
 
-	for (auto* col: cols)
+	for (auto* col : cols)
 		col->setSuppressDataChangedSignal(true);
 
 	SortDialog* dlg = new SortDialog();
 	connect(dlg, SIGNAL(sort(Column*,QVector<Column*>,bool)), m_spreadsheet, SLOT(sortColumns(Column*,QVector<Column*>,bool)));
 	dlg->setColumns(cols);
 	int rc = dlg->exec();
 
-	for (auto* col: cols) {
+	for (auto* col : cols) {
 		col->setSuppressDataChangedSignal(false);
 		if (rc == QDialog::Accepted)
 			col->setChanged();
 	}
 }
 
 void SpreadsheetView::sortColumnAscending() {
 	QVector<Column*> cols = selectedColumns();
 	for (auto* col : cols)
 		col->setSuppressDataChangedSignal(true);
 	m_spreadsheet->sortColumns(cols.first(), cols, true);
-	for (auto* col: cols) {
+	for (auto* col : cols) {
 		col->setSuppressDataChangedSignal(false);
 		col->setChanged();
 	}
 }
 
 void SpreadsheetView::sortColumnDescending() {
 	QVector<Column*> cols = selectedColumns();
 	for (auto* col : cols)
 		col->setSuppressDataChangedSignal(true);
 	m_spreadsheet->sortColumns(cols.first(), cols, false);
-	for (auto* col: cols) {
+	for (auto* col : cols) {
 		col->setSuppressDataChangedSignal(false);
 		col->setChanged();
 	}
 }
 
 /*!
   Cause a repaint of the header.
 */
 void SpreadsheetView::updateHeaderGeometry(Qt::Orientation o, int first, int last) {
 	Q_UNUSED(first)
 	Q_UNUSED(last)
 	//TODO
 	if (o != Qt::Horizontal) return;
 	m_tableView->horizontalHeader()->setStretchLastSection(true);  // ugly hack (flaw in Qt? Does anyone know a better way?)
 	m_tableView->horizontalHeader()->updateGeometry();
 	m_tableView->horizontalHeader()->setStretchLastSection(false); // ugly hack part 2
 }
 
 /*!
   selects the column \c column in the speadsheet view .
 */
 void SpreadsheetView::selectColumn(int column) {
 	QItemSelection selection(m_model->index(0, column), m_model->index(m_spreadsheet->rowCount()-1, column) );
 	m_suppressSelectionChangedEvent = true;
 	m_tableView->selectionModel()->select(selection, QItemSelectionModel::Select);
 	m_suppressSelectionChangedEvent = false;
 }
 
 /*!
   deselects the column \c column in the speadsheet view .
 */
 void SpreadsheetView::deselectColumn(int column) {
 	QItemSelection selection(m_model->index(0, column), m_model->index(m_spreadsheet->rowCount()-1, column) );
 	m_suppressSelectionChangedEvent = true;
 	m_tableView->selectionModel()->select(selection, QItemSelectionModel::Deselect);
 	m_suppressSelectionChangedEvent = false;
 }
 
 /*!
   called when a column in the speadsheet view was clicked (click in the header).
   Propagates the selection of the column to the \c Spreadsheet object
   (a click in the header always selects the column).
 */
 void SpreadsheetView::columnClicked(int column) {
 	m_spreadsheet->setColumnSelectedInView(column, true);
 }
 
 /*!
   called on selections changes. Propagates the selection/deselection of columns to the \c Spreadsheet object.
 */
 void SpreadsheetView::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected) {
 	Q_UNUSED(selected);
 	Q_UNUSED(deselected);
 
 	if (m_suppressSelectionChangedEvent)
 		return;
 
 	QItemSelectionModel* selModel = m_tableView->selectionModel();
 	for (int i=0; i<m_spreadsheet->columnCount(); i++)
 		m_spreadsheet->setColumnSelectedInView(i, selModel->isColumnSelected(i, QModelIndex()));
 }
 
 bool SpreadsheetView::exportView() {
 	ExportSpreadsheetDialog* dlg = new ExportSpreadsheetDialog(this);
 	dlg->setFileName(m_spreadsheet->name());
 
 	dlg->setExportTo(QStringList() << i18n("FITS image") << i18n("FITS table"));
 	for (int i = 0; i < m_spreadsheet->columnCount(); ++i) {
 		if (m_spreadsheet->column(i)->columnMode() != AbstractColumn::Numeric) {
 			dlg->setExportToImage(false);
 			break;
 		}
 	}
 	if (selectedColumnCount() == 0)
 		dlg->setExportSelection(false);
 
 	bool ret;
 	if ((ret = dlg->exec()) == QDialog::Accepted) {
 		const QString path = dlg->path();
 		const bool exportHeader = dlg->exportHeader();
 		WAIT_CURSOR;
 		if (dlg->format() == ExportSpreadsheetDialog::LaTeX) {
 			const bool exportLatexHeader = dlg->exportLatexHeader();
 			const bool gridLines = dlg->gridLines();
 			const bool captions = dlg->captions();
 			const bool skipEmptyRows =dlg->skipEmptyRows();
 			const bool exportEntire = dlg->entireSpreadheet();
 			exportToLaTeX(path, exportHeader, gridLines, captions,
 			                    exportLatexHeader, skipEmptyRows, exportEntire);
 		} else if (dlg->format() == ExportSpreadsheetDialog::FITS) {
 			const int exportTo = dlg->exportToFits();
 			const bool commentsAsUnits = dlg->commentsAsUnitsFits();
 			exportToFits(path, exportTo, commentsAsUnits);
 		} else {
 			const QString separator = dlg->separator();
 			const QLocale::Language format = dlg->numberFormat();
 			exportToFile(path, exportHeader, separator, format);
 		}
 		RESET_CURSOR;
 	}
 	delete dlg;
 
 	return ret;
 }
 
 bool SpreadsheetView::printView() {
 	QPrinter printer;
 	QPrintDialog* dlg = new QPrintDialog(&printer, this);
 	dlg->setWindowTitle(i18nc("@title:window", "Print Spreadsheet"));
 
 	bool ret;
 	if ((ret = dlg->exec()) == QDialog::Accepted) {
 		print(&printer);
 	}
 	delete dlg;
 	return ret;
 }
 
 bool SpreadsheetView::printPreview() {
 	QPrintPreviewDialog* dlg = new QPrintPreviewDialog(this);
 	connect(dlg, &QPrintPreviewDialog::paintRequested, this, &SpreadsheetView::print);
 	return dlg->exec();
 }
 
 /*!
   prints the complete spreadsheet to \c printer.
  */
 void SpreadsheetView::print(QPrinter* printer) const {
 	WAIT_CURSOR;
 	QPainter painter (printer);
 
 	const int dpiy = printer->logicalDpiY();
 	const int margin = (int) ( (1/2.54)*dpiy ); // 1 cm margins
 
 	QHeaderView *hHeader = m_tableView->horizontalHeader();
 	QHeaderView *vHeader = m_tableView->verticalHeader();
 
 	const int rows = m_spreadsheet->rowCount();
 	const int cols = m_spreadsheet->columnCount();
 	int height = margin;
 	int i;
 	const int vertHeaderWidth = vHeader->width();
 	int right = margin + vertHeaderWidth;
 
 	int columnsPerTable = 0;
 	int headerStringWidth = 0;
 	int firstRowStringWidth = 0;
 	bool tablesNeeded = false;
 	for (int col = 0; col < cols; ++col) {
 		headerStringWidth += m_tableView->columnWidth(col);
 		firstRowStringWidth += m_spreadsheet->column(col)->asStringColumn()->textAt(0).length();
 		if ((headerStringWidth >= printer->pageRect().width() -2*margin) ||
 		        (firstRowStringWidth >= printer->pageRect().width() - 2*margin)) {
 			tablesNeeded = true;
 			break;
 		}
 		columnsPerTable++;
 	}
 
 	int tablesCount = (columnsPerTable != 0) ? cols/columnsPerTable : 0;
 	const int remainingColumns = (columnsPerTable != 0) ? cols % columnsPerTable : cols;
 
 	if (!tablesNeeded) {
 		tablesCount = 1;
 		columnsPerTable = cols;
 	}
 
 	if (remainingColumns > 0)
 		tablesCount++;
 	//Paint the horizontal header first
 	for (int table = 0; table < tablesCount; ++table) {
 		right = margin + vertHeaderWidth;
 
 		painter.setFont(hHeader->font());
 		QString headerString = m_tableView->model()->headerData(0, Qt::Horizontal).toString();
 		QRect br;
 		br = painter.boundingRect(br, Qt::AlignCenter, headerString);
 		QRect tr(br);
 		if (table != 0)
 			height += tr.height();
 		painter.drawLine(right, height, right, height+br.height());
 
 		int w;
 		i = table * columnsPerTable;
 		int toI = table * columnsPerTable + columnsPerTable;
 		if ((remainingColumns > 0) && (table == tablesCount-1)) {
 			i = (tablesCount-1)*columnsPerTable;
 			toI = (tablesCount-1)* columnsPerTable + remainingColumns;
 		}
 
 		for (; i<toI; ++i) {
 			headerString = m_tableView->model()->headerData(i, Qt::Horizontal).toString();
 			w = m_tableView->columnWidth(i);
 			tr.setTopLeft(QPoint(right,height));
 			tr.setWidth(w);
 			tr.setHeight(br.height());
 
 			painter.drawText(tr, Qt::AlignCenter, headerString);
 			right += w;
 			painter.drawLine(right, height, right, height+tr.height());
 
 		}
 
 		painter.drawLine(margin + vertHeaderWidth, height, right-1, height);//first horizontal line
 		height += tr.height();
 		painter.drawLine(margin, height, right-1, height);
 
 		// print table values
 		QString cellText;
 		for (i=0; i<rows; ++i) {
 			right = margin;
 			cellText = m_tableView->model()->headerData(i, Qt::Vertical).toString()+'\t';
 			tr = painter.boundingRect(tr, Qt::AlignCenter, cellText);
 			painter.drawLine(right, height, right, height+tr.height());
 
 			br.setTopLeft(QPoint(right,height));
 			br.setWidth(vertHeaderWidth);
 			br.setHeight(tr.height());
 			painter.drawText(br, Qt::AlignCenter, cellText);
 			right += vertHeaderWidth;
 			painter.drawLine(right, height, right, height+tr.height());
 			int j = table * columnsPerTable;
 			int toJ = table * columnsPerTable + columnsPerTable;
 			if ((remainingColumns > 0) && (table == tablesCount-1)) {
 				j = (tablesCount-1)*columnsPerTable;
 				toJ = (tablesCount-1)* columnsPerTable + remainingColumns;
 			}
 			for (; j< toJ; j++) {
 				int w = m_tableView->columnWidth(j);
 				cellText = m_spreadsheet->column(j)->isValid(i) ? m_spreadsheet->text(i,j)+'\t':
 				           QLatin1String("- \t");
 				tr = painter.boundingRect(tr,Qt::AlignCenter,cellText);
 				br.setTopLeft(QPoint(right,height));
 				br.setWidth(w);
 				br.setHeight(tr.height());
 				painter.drawText(br, Qt::AlignCenter, cellText);
 				right += w;
 				painter.drawLine(right, height, right, height+tr.height());
 
 			}
 			height += br.height();
 			painter.drawLine(margin, height, right-1, height);
 
 			if (height >= printer->height()-margin ) {
 				printer->newPage();
 				height = margin;
 				painter.drawLine(margin, height, right, height);
 			}
 		}
 	}
 	RESET_CURSOR;
 }
 
 void SpreadsheetView::exportToFile(const QString& path, const bool exportHeader, const QString& separator, QLocale::Language language) const {
 	QFile file(path);
 	if (!file.open(QFile::WriteOnly | QFile::Truncate))
 		return;
 
 	PERFTRACE("export spreadsheet to file");
 	QTextStream out(&file);
 	const int cols = m_spreadsheet->columnCount();
 
 	QString sep = separator;
 	sep = sep.replace(QLatin1String("TAB"), QLatin1String("\t"), Qt::CaseInsensitive);
 	sep = sep.replace(QLatin1String("SPACE"), QLatin1String(" "), Qt::CaseInsensitive);
 
 	//export header (column names)
 	if (exportHeader) {
 		for (int j = 0; j < cols; ++j) {
 			out << m_spreadsheet->column(j)->name();
 			if (j != cols-1)
 				out << sep;
 		}
 		out << '\n';
 	}
 
 	//export values
 	QLocale locale(language);
 	for (int i = 0; i < m_spreadsheet->rowCount(); ++i) {
 		for (int j = 0; j < cols; ++j) {
 			Column* col = m_spreadsheet->column(j);
 			if (col->columnMode() == AbstractColumn::Numeric) {
 					const Double2StringFilter* out_fltr = static_cast<Double2StringFilter*>(col->outputFilter());
 					out << locale.toString(col->valueAt(i), out_fltr->numericFormat(), 16); // export with max. precision
 			} else
 					out << col->asStringColumn()->textAt(i);
 
 			if (j != cols-1)
 				out << sep;
 		}
 		out << '\n';
 	}
 }
 
 void SpreadsheetView::exportToLaTeX(const QString & path, const bool exportHeaders,
                                     const bool gridLines, const bool captions, const bool latexHeaders,
                                     const bool skipEmptyRows, const bool exportEntire) const {
 	QFile file(path);
 	if (!file.open(QFile::WriteOnly | QFile::Truncate))
 		return;
 
 	QList<Column*> toExport;
 	int cols;
 	int totalRowCount = 0;
 	if (exportEntire) {
 		cols = const_cast<SpreadsheetView*>(this)->m_spreadsheet->columnCount();
 		totalRowCount = m_spreadsheet->rowCount();
 		for (int col = 0; col < cols; ++col)
 			toExport << m_spreadsheet->column(col);
 	} else {
 		cols = const_cast<SpreadsheetView*>(this)->selectedColumnCount();
 		const int firtsSelectedCol = const_cast<SpreadsheetView*>(this)->firstSelectedColumn();
 		bool rowsCalculated = false;
 		for (int col = firtsSelectedCol; col < firtsSelectedCol + cols; ++col) {
 			QVector<QString> textData;
 			for (int row = 0; row < m_spreadsheet->rowCount(); ++row) {
 				if (const_cast<SpreadsheetView*>(this)->isRowSelected(row)) {
 					textData << m_spreadsheet->column(col)->asStringColumn()->textAt(row);
 					if (!rowsCalculated)
 						totalRowCount++;
 				}
 			}
 			if (!rowsCalculated)
 				rowsCalculated = true;
 			Column* column = new Column(m_spreadsheet->column(col)->name(), textData);
 			toExport << column;
 		}
 	}
 	int columnsStringSize = 0;
 	int columnsPerTable = 0;
 
 	for (int i = 0; i < cols; ++i) {
 		int maxSize = -1;
 		for (int j = 0; j < toExport.at(i)->asStringColumn()->rowCount(); ++j) {
 			if (toExport.at(i)->asStringColumn()->textAt(j).size() > maxSize)
 				maxSize = toExport.at(i)->asStringColumn()->textAt(j).size();
 		}
 		columnsStringSize += maxSize;
 		if (!toExport.at(i)->isValid(0))
 			columnsStringSize += 3;
 		if (columnsStringSize > 65)
 			break;
 		++columnsPerTable;
 	}
 
 	const int tablesCount = (columnsPerTable != 0) ? cols/columnsPerTable : 0;
 	const int remainingColumns = (columnsPerTable != 0) ? cols % columnsPerTable : cols;
 
 	bool columnsSeparating = (cols > columnsPerTable);
 	QTextStream out(&file);
 
 	QProcess tex;
 	tex.start("latex", QStringList() << "--version", QProcess::ReadOnly);
 	tex.waitForFinished(500);
 	QString texVersionOutput = QString(tex.readAllStandardOutput());
 	texVersionOutput = texVersionOutput.split('\n')[0];
 
 	int yearidx = -1;
 	for (int i = texVersionOutput.size() - 1; i >= 0; --i) {
 		if (texVersionOutput.at(i) == QChar('2')) {
 			yearidx = i;
 			break;
 		}
 	}
 
 	if (texVersionOutput.at(yearidx+1) == QChar('/'))
 		yearidx-=3;
 
 	bool ok;
 	texVersionOutput.midRef(yearidx, 4).toInt(&ok);
 	int version = -1;
 	if (ok)
 		version = texVersionOutput.midRef(yearidx, 4).toInt(&ok);
 
 	if (latexHeaders) {
 		out << QLatin1String("\\documentclass[11pt,a4paper]{article} \n");
 		out << QLatin1String("\\usepackage{geometry} \n");
 		out << QLatin1String("\\usepackage{xcolor,colortbl} \n");
 		if (version >= 2015)
 			out << QLatin1String("\\extrafloats{1280} \n");
 		out << QLatin1String("\\definecolor{HeaderBgColor}{rgb}{0.81,0.81,0.81} \n");
 		out << QLatin1String("\\geometry{ \n");
 		out << QLatin1String("a4paper, \n");
 		out << QLatin1String("total={170mm,257mm}, \n");
 		out << QLatin1String("left=10mm, \n");
 		out << QLatin1String("top=10mm } \n");
 
 		out << QLatin1String("\\begin{document} \n");
 		out << QLatin1String("\\title{LabPlot Spreadsheet Export to \\LaTeX{} } \n");
 		out << QLatin1String("\\author{LabPlot} \n");
 		out << QLatin1String("\\date{\\today} \n");
 	}
 
 	QString endTabularTable ("\\end{tabular} \n \\end{table} \n");
 	QString tableCaption ("\\caption{"+ m_spreadsheet->name()+ "} \n");
 	QString beginTable ("\\begin{table}[ht] \n");
 
 	int rowCount = 0;
 	const int maxRows = 45;
 	bool captionRemoved = false;
 	if (columnsSeparating) {
 		QVector<int> emptyRowIndices;
 		for (int table = 0; table < tablesCount; ++table) {
 			QStringList textable;
 			captionRemoved = false;
 			textable << beginTable;
 
 			if (captions)
 				textable << tableCaption;
 			textable << QLatin1String("\\centering \n");
 			textable << QLatin1String("\\begin{tabular}{") << (gridLines ?QLatin1String("|") : QLatin1String(""));
 			for (int i = 0; i < columnsPerTable; ++i)
 				textable << ( gridLines ? QLatin1String(" c |") : QLatin1String(" c ") );
 			textable << QLatin1String("} \n");
 			if (gridLines)
 				textable << QLatin1String("\\hline \n");
 
 			if (exportHeaders) {
 				if (latexHeaders)
 					textable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 				for (int col = table*columnsPerTable; col < (table * columnsPerTable) + columnsPerTable; ++col) {
 					textable << toExport.at(col)->name();
 					if (col != ((table * columnsPerTable)+ columnsPerTable)-1)
 						textable << QLatin1String(" & ");
 				}
 				textable << QLatin1String("\\\\ \n");
 				if (gridLines)
 					textable << QLatin1String("\\hline \n");
 			}
 			for (const auto& s : textable)
 				out << s;
 
 			QStringList values;
 			for (int row = 0; row < totalRowCount; ++row) {
 				values.clear();
 				bool notEmpty = false;
 				for (int col = table*columnsPerTable; col < (table * columnsPerTable) + columnsPerTable; ++col ) {
 					if (toExport.at(col)->isValid(row)) {
 						notEmpty = true;
 						values << toExport.at(col)->asStringColumn()->textAt(row);
 					} else
 						values << QLatin1String("-");
 					if (col != ((table * columnsPerTable)+ columnsPerTable)-1)
 						values << QLatin1String(" & ");
 				}
 				if (!notEmpty && skipEmptyRows) {
 					if (!emptyRowIndices.contains(row))
 						emptyRowIndices << row;
 				}
 				if (emptyRowIndices.contains(row) && notEmpty)
 					emptyRowIndices.remove(emptyRowIndices.indexOf(row));
 
 				if (notEmpty || !skipEmptyRows) {
 					for (const auto& s : values)
 						out << s;
 					out << QLatin1String("\\\\ \n");
 					if (gridLines)
 						out << QLatin1String("\\hline \n");
 					rowCount++;
 					if (rowCount == maxRows) {
 						out << endTabularTable;
 						out << QLatin1String("\\newpage \n");
 
 						if (captions)
 							if (!captionRemoved)
 								textable.removeAt(1);
 						for (const auto& s : textable)
 							out << s;
 						rowCount = 0;
 						if (!captionRemoved)
 							captionRemoved = true;
 					}
 				}
 			}
 			out << endTabularTable;
 		}
 
 		//new table for the remaining columns
 		QStringList remainingTable;
 		remainingTable << beginTable;
 		if (captions)
 			remainingTable << tableCaption;
 		remainingTable << QLatin1String("\\centering \n");
 		remainingTable << QLatin1String("\\begin{tabular}{") <<  (gridLines ? QLatin1String("|"):QLatin1String(""));
 		for (int c = 0; c < remainingColumns; ++c)
 			remainingTable << ( gridLines ? QLatin1String(" c |") : QLatin1String(" c ") );
 		remainingTable << QLatin1String("} \n");
 		if (gridLines)
 			remainingTable << QLatin1String("\\hline \n");
 		if (exportHeaders) {
 			if (latexHeaders)
 				remainingTable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 			for (int col = 0; col < remainingColumns; ++col) {
 				remainingTable << toExport.at(col + (tablesCount * columnsPerTable))->name();
 				if (col != remainingColumns-1)
 					remainingTable << QLatin1String(" & ");
 			}
 			remainingTable << QLatin1String("\\\\ \n");
 			if (gridLines)
 				remainingTable << QLatin1String("\\hline \n");
 		}
 
 		for (const auto& s : remainingTable)
 			out << s;
 
 		QStringList values;
 		captionRemoved = false;
 		for (int row = 0; row < totalRowCount; ++row) {
 			values.clear();
 			bool notEmpty = false;
 			for (int col = 0; col < remainingColumns; ++col ) {
 				if (toExport.at(col + (tablesCount * columnsPerTable))->isValid(row)) {
 					notEmpty = true;
 					values << toExport.at(col + (tablesCount * columnsPerTable))->asStringColumn()->textAt(row);
 				} else
 					values << QLatin1String("-");
 				if (col != remainingColumns-1)
 					values << QLatin1String(" & ");
 			}
 			if (!emptyRowIndices.contains(row) && !notEmpty)
 				notEmpty = true;
 			if (notEmpty || !skipEmptyRows) {
 				for (const auto& s : values)
 					out << s;
 				out << QLatin1String("\\\\ \n");
 				if (gridLines)
 					out << QLatin1String("\\hline \n");
 				rowCount++;
 				if (rowCount == maxRows) {
 					out << endTabularTable;
 					out << QLatin1String("\\pagebreak[4] \n");
 					if (captions)
 						if (!captionRemoved)
 							remainingTable.removeAt(1);
 					for (const auto& s : remainingTable)
 						out << s;
 					rowCount = 0;
 					if (!captionRemoved)
 						captionRemoved = true;
 				}
 			}
 		}
 		out << endTabularTable;
 	} else {
 		QStringList textable;
 		textable << beginTable;
 		if (captions)
 			textable << tableCaption;
 		textable << QLatin1String("\\centering \n");
 		textable << QLatin1String("\\begin{tabular}{") << (gridLines ? QLatin1String("|"):QLatin1String(""));
 		for (int c = 0; c < cols; ++c)
 			textable << ( gridLines ? QLatin1String(" c |") : QLatin1String(" c ") );
 		textable << QLatin1String("} \n");
 		if (gridLines)
 			textable << QLatin1String("\\hline \n");
 		if (exportHeaders) {
 			if (latexHeaders)
 				textable << QLatin1String("\\rowcolor{HeaderBgColor} \n");
 			for (int col = 0; col < cols; ++col) {
 				textable << toExport.at(col)->name();
 				if (col != cols-1)
 					textable << QLatin1String(" & ");
 			}
 			textable << QLatin1String("\\\\ \n");
 			if (gridLines)
 				textable << QLatin1String("\\hline \n");
 		}
 
 		for (const auto& s : textable)
 			out << s;
 		QStringList values;
 		captionRemoved = false;
 		for (int row = 0; row < totalRowCount; ++row) {
 			values.clear();
 			bool notEmpty = false;
 
 			for (int col = 0; col < cols; ++col ) {
 				if (toExport.at(col)->isValid(row)) {
 					notEmpty = true;
 					values << toExport.at(col)->asStringColumn()->textAt(row);
 				} else
 					values << "-";
 				if (col != cols-1)
 					values << " & ";
 			}
 
 			if (notEmpty || !skipEmptyRows) {
 				for (const auto& s : values)
 					out << s;
 				out << QLatin1String("\\\\ \n");
 				if (gridLines)
 					out << QLatin1String("\\hline \n");
 				rowCount++;
 				if (rowCount == maxRows) {
 					out << endTabularTable;
 					out << QLatin1String("\\newpage \n");
 					if (captions)
 						if (!captionRemoved)
 							textable.removeAt(1);
 					for (const auto& s : textable)
 						out << s;
 					rowCount = 0;
 					if (!captionRemoved)
 						captionRemoved = true;
 				}
 			}
 		}
 		out << endTabularTable;
 	}
 	if (latexHeaders)
 		out << QLatin1String("\\end{document} \n");
 
 	if (!exportEntire) {
 		qDeleteAll(toExport);
 		toExport.clear();
 	} else
 		toExport.clear();
 }
 
 void SpreadsheetView::exportToFits(const QString &fileName, const int exportTo, const bool commentsAsUnits) const {
 	FITSFilter* filter = new FITSFilter;
 
 	filter->setExportTo(exportTo);
 	filter->setCommentsAsUnits(commentsAsUnits);
 	filter->write(fileName, m_spreadsheet);
 
 	delete filter;
 }
diff --git a/src/kdefrontend/GuiObserver.cpp b/src/kdefrontend/GuiObserver.cpp
index 2ab2a97de..d2db6c6a3 100644
--- a/src/kdefrontend/GuiObserver.cpp
+++ b/src/kdefrontend/GuiObserver.cpp
@@ -1,680 +1,680 @@
 /***************************************************************************
 	File                 : GuiObserver.cpp
 	Project              : LabPlot
 	Description 		 : GUI observer
 --------------------------------------------------------------------
 	Copyright            : (C) 2010-2015 Alexander Semke (alexander.semke@web.de)
 	Copyright            : (C) 2015-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
 	Copyright            : (C) 2016 Garvit Khatri (garvitdelhi@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 "kdefrontend/GuiObserver.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/AbstractAspect.h"
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlotLegend.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/CustomPoint.h"
 #include "backend/worksheet/plots/cartesian/Histogram.h"
 #include "backend/worksheet/plots/cartesian/BarChartPlot.h"
 #include "backend/worksheet/TextLabel.h"
 #ifdef HAVE_CANTOR_LIBS
 #include "backend/cantorWorksheet/CantorWorksheet.h"
 #endif
 #ifdef HAVE_MQTT
 #include "backend/datasources/MQTTClient.h"
 #include "backend/datasources/MQTTSubscription.h"
 #include "backend/datasources/MQTTTopic.h"
 #endif
 #include "backend/core/Project.h"
 #include "backend/datapicker/Datapicker.h"
 #include "backend/datapicker/DatapickerImage.h"
 #include "backend/datapicker/DatapickerCurve.h"
 #include "commonfrontend/ProjectExplorer.h"
 #include "kdefrontend/MainWin.h"
 #include "kdefrontend/dockwidgets/AxisDock.h"
 #include "kdefrontend/dockwidgets/NoteDock.h"
 #include "kdefrontend/dockwidgets/CartesianPlotDock.h"
 #include "kdefrontend/dockwidgets/CartesianPlotLegendDock.h"
 #include "kdefrontend/dockwidgets/ColumnDock.h"
 #include "kdefrontend/dockwidgets/LiveDataDock.h"
 #include "kdefrontend/dockwidgets/MatrixDock.h"
 #include "kdefrontend/dockwidgets/ProjectDock.h"
 #include "kdefrontend/dockwidgets/SpreadsheetDock.h"
 #include "kdefrontend/dockwidgets/XYCurveDock.h"
 #include "kdefrontend/dockwidgets/HistogramDock.h"
 #include "kdefrontend/dockwidgets/XYEquationCurveDock.h"
 #include "kdefrontend/dockwidgets/XYDataReductionCurveDock.h"
 #include "kdefrontend/dockwidgets/XYDifferentiationCurveDock.h"
 #include "kdefrontend/dockwidgets/XYIntegrationCurveDock.h"
 #include "kdefrontend/dockwidgets/XYInterpolationCurveDock.h"
 #include "kdefrontend/dockwidgets/XYSmoothCurveDock.h"
 #include "kdefrontend/dockwidgets/XYFitCurveDock.h"
 #include "kdefrontend/dockwidgets/XYFourierFilterCurveDock.h"
 #include "kdefrontend/dockwidgets/XYFourierTransformCurveDock.h"
 #include "kdefrontend/dockwidgets/XYConvolutionCurveDock.h"
 #include "kdefrontend/dockwidgets/XYCorrelationCurveDock.h"
 #include "kdefrontend/dockwidgets/CustomPointDock.h"
 #include "kdefrontend/dockwidgets/WorksheetDock.h"
 #ifdef HAVE_CANTOR_LIBS
 #include "kdefrontend/dockwidgets/CantorWorksheetDock.h"
 #endif
 #include "kdefrontend/widgets/LabelWidget.h"
 #include "kdefrontend/widgets/DatapickerImageWidget.h"
 #include "kdefrontend/widgets/DatapickerCurveWidget.h"
 
 #include <QDockWidget>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QToolBar>
 #include <KI18n/KLocalizedString>
 
 /*!
   \class GuiObserver
   \brief The GUI observer looks for the selection changes in the main window
   and shows/hides the correspondings dock widgets, toolbars etc.
   This class is intended to simplify (or not to overload) the code in MainWin.
 
   \ingroup kdefrontend
 */
 
 GuiObserver::GuiObserver(MainWin* mainWin) {
 	connect(mainWin->m_projectExplorer, SIGNAL(selectedAspectsChanged(QList<AbstractAspect*>&)),
 	        this, SLOT(selectedAspectsChanged(QList<AbstractAspect*>&)) );
 	connect(mainWin->m_projectExplorer, SIGNAL(hiddenAspectSelected(const AbstractAspect*)),
 	        this, SLOT(hiddenAspectSelected(const AbstractAspect*)) );
 	m_mainWindow = mainWin;
 }
 
 
 /*!
   called on selection changes in the project explorer.
   Determines the type of the currently selected objects (aspects)
   and activates the corresponding dockwidgets, toolbars etc.
 */
 void GuiObserver::selectedAspectsChanged(QList<AbstractAspect*>& selectedAspects) const {
 	if (selectedAspects.isEmpty()) {
 		if (m_mainWindow->stackedWidget->currentWidget())
 			m_mainWindow->stackedWidget->currentWidget()->hide();
 
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Properties"));
 		return;
 	}
 
 	QString prevClassName, className;
 
 	//check, whether objects of different types where selected
 	//don't show any dock widgets in this case.
-	for (auto* aspect: selectedAspects) {
+	for (auto* aspect : selectedAspects) {
 		className = aspect->metaObject()->className();
 		if (className != prevClassName && !prevClassName.isEmpty()) {
 			if (m_mainWindow->stackedWidget->currentWidget())
 				m_mainWindow->stackedWidget->currentWidget()->hide();
 
 			m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Properties"));
 			return;
 		}
 		prevClassName = className;
 	}
 
 	if (m_mainWindow->stackedWidget->currentWidget())
 		m_mainWindow->stackedWidget->currentWidget()->show();
 
 	if (className == "Spreadsheet") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Spreadsheet"));
 
 		if (!m_mainWindow->spreadsheetDock) {
 			m_mainWindow->spreadsheetDock = new SpreadsheetDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->spreadsheetDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->spreadsheetDock);
 		}
 
 		QList<Spreadsheet*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Spreadsheet *>(aspect);
 		m_mainWindow->spreadsheetDock->setSpreadsheets(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->spreadsheetDock);
 	} else if (className == "Column") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Column"));
 
 		if (!m_mainWindow->columnDock) {
 			m_mainWindow->columnDock = new ColumnDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->columnDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->columnDock);
 		}
 
 		QList<Column*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Column *>(aspect);
 		m_mainWindow->columnDock->setColumns(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->columnDock);
 	} else if (className == "Matrix") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Matrix"));
 
 		if (!m_mainWindow->matrixDock) {
 			m_mainWindow->matrixDock = new MatrixDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->matrixDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->matrixDock);
 		}
 
 		QList<Matrix*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Matrix*>(aspect);
 		m_mainWindow->matrixDock->setMatrices(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->matrixDock);
 	} else if (className == "Worksheet") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Worksheet"));
 
 		if (!m_mainWindow->worksheetDock) {
 			m_mainWindow->worksheetDock = new WorksheetDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->worksheetDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->worksheetDock);
 		}
 
 		QList<Worksheet*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Worksheet *>(aspect);
 		m_mainWindow->worksheetDock->setWorksheets(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->worksheetDock);
 	} else if (className == "CartesianPlot") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Cartesian Plot"));
 
 		if (!m_mainWindow->cartesianPlotDock) {
 			m_mainWindow->cartesianPlotDock = new CartesianPlotDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->cartesianPlotDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->cartesianPlotDock);
 		}
 
 		QList<CartesianPlot*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<CartesianPlot *>(aspect);
 		m_mainWindow->cartesianPlotDock->setPlots(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->cartesianPlotDock);
 	} else if (className == "CartesianPlotLegend") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Legend"));
 
 		if (!m_mainWindow->cartesianPlotLegendDock) {
 			m_mainWindow->cartesianPlotLegendDock = new CartesianPlotLegendDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->cartesianPlotLegendDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->cartesianPlotLegendDock);
 		}
 
 		QList<CartesianPlotLegend*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<CartesianPlotLegend*>(aspect);
 		m_mainWindow->cartesianPlotLegendDock->setLegends(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->cartesianPlotLegendDock);
 	} else if (className == "Axis") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Axis"));
 
 		if (!m_mainWindow->axisDock) {
 			m_mainWindow->axisDock = new AxisDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->axisDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->axisDock);
 		}
 
 		QList<Axis*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Axis *>(aspect);
 		m_mainWindow->axisDock->setAxes(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->axisDock);
 	} else if (className == "XYCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "xy-Curve"));
 
 		if (!m_mainWindow->xyCurveDock) {
 			m_mainWindow->xyCurveDock = new XYCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyCurveDock->setupGeneral();
 			connect(m_mainWindow->xyCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve *>(aspect);
 		m_mainWindow->xyCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyCurveDock);
 	} else if (className == "XYEquationCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "xy-Equation"));
 
 		if (!m_mainWindow->xyEquationCurveDock) {
 			m_mainWindow->xyEquationCurveDock = new XYEquationCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyEquationCurveDock->setupGeneral();
 			connect(m_mainWindow->xyEquationCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyEquationCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve *>(aspect);
 		m_mainWindow->xyEquationCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyEquationCurveDock);
 	} else if (className == "XYDataReductionCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Data Reduction"));
 
 		if (!m_mainWindow->xyDataReductionCurveDock) {
 			m_mainWindow->xyDataReductionCurveDock = new XYDataReductionCurveDock(m_mainWindow->stackedWidget, m_mainWindow->statusBar());
 			m_mainWindow->xyDataReductionCurveDock->setupGeneral();
 			connect(m_mainWindow->xyDataReductionCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyDataReductionCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyDataReductionCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyDataReductionCurveDock);
 	} else if (className == "XYDifferentiationCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Differentiation"));
 
 		if (!m_mainWindow->xyDifferentiationCurveDock) {
 			m_mainWindow->xyDifferentiationCurveDock = new XYDifferentiationCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyDifferentiationCurveDock->setupGeneral();
 			connect(m_mainWindow->xyDifferentiationCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyDifferentiationCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyDifferentiationCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyDifferentiationCurveDock);
 	} else if (className == "XYIntegrationCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Integration"));
 
 		if (!m_mainWindow->xyIntegrationCurveDock) {
 			m_mainWindow->xyIntegrationCurveDock = new XYIntegrationCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyIntegrationCurveDock->setupGeneral();
 			connect(m_mainWindow->xyIntegrationCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyIntegrationCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyIntegrationCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyIntegrationCurveDock);
 	} else if (className == "XYInterpolationCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Interpolation"));
 
 		if (!m_mainWindow->xyInterpolationCurveDock) {
 			m_mainWindow->xyInterpolationCurveDock = new XYInterpolationCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyInterpolationCurveDock->setupGeneral();
 			connect(m_mainWindow->xyInterpolationCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyInterpolationCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyInterpolationCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyInterpolationCurveDock);
 	} else if (className == "XYSmoothCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Smoothing"));
 
 		if (!m_mainWindow->xySmoothCurveDock) {
 			m_mainWindow->xySmoothCurveDock = new XYSmoothCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xySmoothCurveDock->setupGeneral();
 			connect(m_mainWindow->xySmoothCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xySmoothCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xySmoothCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xySmoothCurveDock);
 	} else if (className == "XYFitCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Fit"));
 
 		if (!m_mainWindow->xyFitCurveDock) {
 			m_mainWindow->xyFitCurveDock = new XYFitCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyFitCurveDock->setupGeneral();
 			connect(m_mainWindow->xyFitCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyFitCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyFitCurveDock->setCurves(list);
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyFitCurveDock);
 	} else if (className == "XYFourierTransformCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Fourier Transform"));
 
 		if (!m_mainWindow->xyFourierTransformCurveDock) {
 			m_mainWindow->xyFourierTransformCurveDock = new XYFourierTransformCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyFourierTransformCurveDock->setupGeneral();
 			connect(m_mainWindow->xyFourierTransformCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyFourierTransformCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 
 		m_mainWindow->xyFourierTransformCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyFourierTransformCurveDock);
 	} else if (className == "XYFourierFilterCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Fourier Filter"));
 
 		if (!m_mainWindow->xyFourierFilterCurveDock) {
 			m_mainWindow->xyFourierFilterCurveDock = new XYFourierFilterCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyFourierFilterCurveDock->setupGeneral();
 			connect(m_mainWindow->xyFourierFilterCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyFourierFilterCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyFourierFilterCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyFourierFilterCurveDock);
 	} else if (className == "XYConvolutionCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Convolution/Deconvolution"));
 
 		if (!m_mainWindow->xyConvolutionCurveDock) {
 			m_mainWindow->xyConvolutionCurveDock = new XYConvolutionCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyConvolutionCurveDock->setupGeneral();
 			connect(m_mainWindow->xyConvolutionCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyConvolutionCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyConvolutionCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyConvolutionCurveDock);
 	} else if (className == "XYCorrelationCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Correlation"));
 
 		if (!m_mainWindow->xyCorrelationCurveDock) {
 			m_mainWindow->xyCorrelationCurveDock = new XYCorrelationCurveDock(m_mainWindow->stackedWidget);
 			m_mainWindow->xyCorrelationCurveDock->setupGeneral();
 			connect(m_mainWindow->xyCorrelationCurveDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->xyCorrelationCurveDock);
 		}
 
 		QList<XYCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<XYCurve*>(aspect);
 		m_mainWindow->xyCorrelationCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->xyCorrelationCurveDock);
 	} else if (className=="Histogram") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Histogram Properties"));
 
 		if (!m_mainWindow->histogramDock) {
 			m_mainWindow->histogramDock = new HistogramDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->histogramDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->histogramDock);
 		}
 
 		QList<Histogram*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list<<qobject_cast<Histogram *>(aspect);
 		m_mainWindow->histogramDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->histogramDock);
 	} else if (className == "TextLabel") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Text Label"));
 
 		if (!m_mainWindow->textLabelDock) {
 			m_mainWindow->textLabelDock = new LabelWidget(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->textLabelDock);
 		}
 
 		QList<TextLabel*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<TextLabel*>(aspect);
 		m_mainWindow->textLabelDock->setLabels(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->textLabelDock);
 	} else if (className == "CustomPoint") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Custom Point"));
 
 		if (!m_mainWindow->customPointDock) {
 			m_mainWindow->customPointDock = new CustomPointDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->customPointDock);
 		}
 
 		QList<CustomPoint*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<CustomPoint*>(aspect);
 		m_mainWindow->customPointDock->setPoints(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->customPointDock);
 	} else if (className == "DatapickerCurve") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Datapicker Curve"));
 
 		if (!m_mainWindow->datapickerCurveDock) {
 			m_mainWindow->datapickerCurveDock = new DatapickerCurveWidget(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->datapickerCurveDock);
 		}
 
 		QList<DatapickerCurve*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<DatapickerCurve*>(aspect);
 		m_mainWindow->datapickerCurveDock->setCurves(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->datapickerCurveDock);
 	} else if (className == "Datapicker") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Datapicker"));
 
 		if (!m_mainWindow->datapickerImageDock) {
 			m_mainWindow->datapickerImageDock = new DatapickerImageWidget(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->datapickerImageDock);
 		}
 
 		QList<DatapickerImage*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Datapicker*>(aspect)->image();
 		m_mainWindow->datapickerImageDock->setImages(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->datapickerImageDock);
 	} else if (className == "Project") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Project"));
 
 		if (!m_mainWindow->projectDock) {
 			m_mainWindow->projectDock = new ProjectDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->projectDock);
 		}
 
 		m_mainWindow->projectDock->setProject(m_mainWindow->m_project);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->projectDock);
 	} else if (className=="CantorWorksheet") {
 #ifdef HAVE_CANTOR_LIBS
 		if (!m_mainWindow->cantorWorksheetDock) {
 			m_mainWindow->cantorWorksheetDock = new CantorWorksheetDock(m_mainWindow->stackedWidget);
 			connect(m_mainWindow->cantorWorksheetDock, SIGNAL(info(QString)), m_mainWindow->statusBar(), SLOT(showMessage(QString)));
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->cantorWorksheetDock);
 		}
 
 		QList<CantorWorksheet*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<CantorWorksheet *>(aspect);
 		if (list.size() == 1)
 			m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window %1 is a Cantor backend", "%1 Properties", list.first()->backendName()));
 		else
 			m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "CAS Properties"));
 		m_mainWindow->cantorWorksheetDock->setCantorWorksheets(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->cantorWorksheetDock);
 #endif
 	} else if (className == "Notes") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Notes"));
 
 		if (!m_mainWindow->notesDock) {
 			m_mainWindow->notesDock = new NoteDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->notesDock);
 		}
 
 		QList<Note*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<Note*>(aspect);
 		m_mainWindow->notesDock->setNotesList(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->notesDock);
 	}
 #ifdef HAVE_MQTT
 	else if (className == "MQTTClient") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18n("MQTT Data Source"));
 
 		if (!m_mainWindow->m_liveDataDock) {
 			qDebug()<<"new live data dock";
 			m_mainWindow->m_liveDataDock = new LiveDataDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->m_liveDataDock);
 		}
 
 		QList<MQTTClient*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<MQTTClient*>(aspect);
 		m_mainWindow->m_liveDataDock->setMQTTClients(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->m_liveDataDock);
 	} else if (className == "MQTTSubscription") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18n("MQTT Data Source"));
 
 		if (!m_mainWindow->m_liveDataDock) {
 			qDebug()<<"new live data dock";
 			m_mainWindow->m_liveDataDock = new LiveDataDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->m_liveDataDock);
 		}
 
 		QList<MQTTClient*> list;
-		for (auto* aspect: selectedAspects) {
+		for (auto* aspect : selectedAspects) {
 			QString clientName = qobject_cast<MQTTSubscription*>(aspect)->mqttClient()->name();
 			bool found = false;
 			for (int i = 0; i < list.size(); ++i) {
 				if(list.at(i)->name() == clientName) {
 					found = true;
 					break;
 				}
 			}
 			if(!found)
 				list << qobject_cast<MQTTSubscription*>(aspect)->mqttClient();
 		}
 		m_mainWindow->m_liveDataDock->setMQTTClients(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->m_liveDataDock);
 	} else if (className == "MQTTTopic") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18n("MQTT Data Source"));
 
 		if (!m_mainWindow->m_liveDataDock) {
 			m_mainWindow->m_liveDataDock = new LiveDataDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->m_liveDataDock);
 		}
 
 		QList<MQTTClient*> list;
-		for (auto* aspect: selectedAspects) {
+		for (auto* aspect : selectedAspects) {
 			QString clientName = qobject_cast<MQTTClient*>(qobject_cast<MQTTTopic*>(aspect)->mqttClient())->name();
 			bool found = false;
 			for (int i = 0; i < list.size(); ++i) {
 				if(list.at(i)->name() == clientName) {
 					found = true;
 					break;
 				}
 			}
 			if(!found)
 				list << qobject_cast<MQTTClient*>(qobject_cast<MQTTTopic*>(aspect)->mqttClient());
 		}
 		m_mainWindow->m_liveDataDock->setMQTTClients(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->m_liveDataDock);
 	}
 #endif
 	else if (className == "LiveDataSource") {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Live Data Source"));
 
 		if (!m_mainWindow->m_liveDataDock) {
 			m_mainWindow->m_liveDataDock = new LiveDataDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->m_liveDataDock);
 		}
 
 		QList<LiveDataSource*> list;
-		for (auto* aspect: selectedAspects)
+		for (auto* aspect : selectedAspects)
 			list << qobject_cast<LiveDataSource*>(aspect);
 		m_mainWindow->m_liveDataDock->setLiveDataSources(list);
 
 		m_mainWindow->stackedWidget->setCurrentWidget(m_mainWindow->m_liveDataDock);
 	} else {
 		m_mainWindow->m_propertiesDock->setWindowTitle(i18nc("@title:window", "Properties"));
 		if (m_mainWindow->stackedWidget->currentWidget())
 			m_mainWindow->stackedWidget->currentWidget()->hide();
 	}
 }
 
 /*!
 	handles the selection of a hidden aspect \c aspect in the view (relevant for WorksheetView only at the moment).
 	Currently, a hidden aspect can only be a plot title lable or an axis label.
 	-> Activate the corresponding DockWidget and make the title tab current.
  */
 void GuiObserver::hiddenAspectSelected(const AbstractAspect* aspect) const {
 	const AbstractAspect* parent = aspect->parentAspect();
 	if (!parent)
 		return;
 
 	QString className = parent->metaObject()->className();
 	if (className == "Axis") {
 		if (!m_mainWindow->axisDock) {
 			m_mainWindow->axisDock = new AxisDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->axisDock);
 		}
 		m_mainWindow->axisDock->activateTitleTab();
 	} else if (className == "CartesianPlot") {
 		if (!m_mainWindow->cartesianPlotDock) {
 			m_mainWindow->cartesianPlotDock = new CartesianPlotDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->cartesianPlotDock);
 		}
 		m_mainWindow->cartesianPlotDock->activateTitleTab();
 	} else if (className == "CartesianPlotLegend") {
 		if (!m_mainWindow->cartesianPlotLegendDock) {
 			m_mainWindow->cartesianPlotLegendDock = new CartesianPlotLegendDock(m_mainWindow->stackedWidget);
 			m_mainWindow->stackedWidget->addWidget(m_mainWindow->cartesianPlotLegendDock);
 		}
 		m_mainWindow->cartesianPlotLegendDock->activateTitleTab();
 	}
 }
 
diff --git a/src/kdefrontend/GuiTools.cpp b/src/kdefrontend/GuiTools.cpp
index ca507e2fc..3922118c3 100644
--- a/src/kdefrontend/GuiTools.cpp
+++ b/src/kdefrontend/GuiTools.cpp
@@ -1,229 +1,229 @@
 /***************************************************************************
     File                 : GuiTools.cpp
     Project              : LabPlot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2013 Alexander Semke (alexander.semke*web.de)
                            (replace * with @ in the email addresses)
     Description          :  constains several static functions which are used on frequently throughout the kde frontend.
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "GuiTools.h"
 #include <KI18n/KLocalizedString>
 
 #include <QApplication>
 #include <QComboBox>
 #include <QMenu>
 #include <QColor>
 #include <QPainter>
 
 static const int colorsCount = 26;
 static QColor colors[colorsCount] = {QColor(255,255,255), QColor(0,0,0),
 							QColor(192,0,0), QColor(255,0,0), QColor(255,192,192), //red
 							QColor(0,192,0), QColor(0,255,0), QColor(192,255,192), //green
 							QColor(0,0,192), QColor(0,0,255), QColor(192,192,255), //blue
 							QColor(192,192,0), QColor(255,255,0), QColor(255,255,192), //yellow
 							QColor(0,192,192), QColor(0,255,255), QColor(192,255,255), //cyan
 							QColor(192,0,192), QColor(255,0,255), QColor(255,192,255), //magenta
 							QColor(192,88,0), QColor(255,128,0), QColor(255,168,88), //orange
 							QColor(128,128,128), QColor(160,160,160), QColor(195,195,195) //grey
 							};
 
 /*!
 	fills the ComboBox \c combobox with the six possible Qt::PenStyles, the color \c color is used.
 */
 void GuiTools::updatePenStyles(QComboBox* comboBox, const QColor& color){
-	int index=comboBox->currentIndex();
+	int index = comboBox->currentIndex();
 	comboBox->clear();
 
 	QPainter pa;
-	int offset=2;
-	int w=50;
-	int h=10;
-	QPixmap pm( w, h );
-	comboBox->setIconSize( QSize(w,h) );
+	int offset = 2;
+	int w = 50;
+	int h = 10;
+	QPixmap pm(w, h);
+	comboBox->setIconSize(QSize(w,h));
 
 	//loop over six possible Qt-PenStyles, draw on the pixmap and insert it
 	static QString list[6] = { i18n("No Line"), i18n("Solid Line"), i18n("Dash Line"),
 							   i18n("Dot Line"), i18n("Dash-dot Line"), i18n("Dash-dot-dot Line") };
-	for (int i=0;i<6;i++){
+	for (int i = 0; i < 6; i++) {
 		pm.fill(Qt::transparent);
-		pa.begin( &pm );
-		pa.setPen( QPen( color, 1, (Qt::PenStyle)i ) );
-		pa.drawLine( offset, h/2, w-offset, h/2);
+		pa.begin(&pm);
+		pa.setPen( QPen(color, 1, (Qt::PenStyle)i) );
+		pa.drawLine(offset, h/2, w-offset, h/2);
 		pa.end();
 		comboBox->addItem( QIcon(pm), list[i] );
 	}
 	comboBox->setCurrentIndex(index);
 }
 
 /*!
 	fills the QMenu \c menu with the six possible Qt::PenStyles, the color \c color is used.
 	QActions are created with \c actionGroup as the parent, if not available.
 	If already available, onle the color in the QAction's icons is updated.
 */
 void GuiTools::updatePenStyles(QMenu* menu, QActionGroup* actionGroup, const QColor& color){
 	QPainter pa;
-	int offset=2;
-	int w=50;
-	int h=10;
-	QPixmap pm( w, h );
+	int offset = 2;
+	int w = 50;
+	int h = 10;
+	QPixmap pm(w, h);
 
 	//loop over six possible Qt-PenStyles, draw on the pixmap and insert it
 	static QString list[6] = { i18n("No Line"), i18n("Solid Line"), i18n("Dash Line"),
 							   i18n("Dot Line"), i18n("Dash-dot Line"), i18n("Dash-dot-dot Line") };
 
 	QAction* action;
-	if (actionGroup->actions().isEmpty()){
+	if (actionGroup->actions().isEmpty()) {
 		//TODO setting of the icon size doesn't work here
 		menu->setStyleSheet( "QMenu::icon { width:50px; height:10px; }" );
 
-		for (int i=0;i<6;i++){
+		for (int i = 0; i < 6; i++) {
 			pm.fill(Qt::transparent);
-			pa.begin( &pm );
+			pa.begin(&pm);
 			pa.setPen( QPen( color, 1, (Qt::PenStyle)i ) );
-			pa.drawLine( offset, h/2, w-offset, h/2);
+			pa.drawLine(offset, h/2, w-offset, h/2);
 			pa.end();
 			action = new QAction( QIcon(pm), list[i], actionGroup );
 			action->setCheckable(true);
 			menu->addAction( action );
 		}
 	}else{
-		for (int i=0;i<6;i++){
+		for (int i = 0; i < 6; i++) {
 			pm.fill(Qt::transparent);
 			pa.begin( &pm );
 			pa.setPen( QPen( color, 1, (Qt::PenStyle)i ) );
-			pa.drawLine( offset, h/2, w-offset, h/2);
+			pa.drawLine(offset, h/2, w-offset, h/2);
 			pa.end();
 			action = actionGroup->actions().at(i);
 			action->setIcon( QIcon(pm) );
 		}
 	}
 }
 
 void GuiTools::selectPenStyleAction(QActionGroup* actionGroup, Qt::PenStyle style) {
-	auto index = (int)style;
+	int index = (int)style;
 	Q_ASSERT(index < actionGroup->actions().size());
 	actionGroup->actions().at(index)->setChecked(true);
 }
 
 Qt::PenStyle GuiTools::penStyleFromAction(QActionGroup* actionGroup, QAction* action) {
 	int index = actionGroup->actions().indexOf(action);
 	return Qt::PenStyle(index);
 }
 
 /*!
 	fills the ComboBox for the symbol filling patterns with the 14 possible Qt::BrushStyles.
 */
 void GuiTools::updateBrushStyles(QComboBox* comboBox, const QColor& color) {
-	int index=comboBox->currentIndex();
+	int index = comboBox->currentIndex();
 	comboBox->clear();
 
 	QPainter pa;
-	int offset=2;
-	int w=50;
-	int h=20;
-	QPixmap pm( w, h );
-	comboBox->setIconSize( QSize(w,h) );
+	int offset = 2;
+	int w = 50;
+	int h = 20;
+	QPixmap pm(w, h);
+	comboBox->setIconSize(QSize(w, h));
 
 	QPen pen(Qt::SolidPattern, 1);
-	pa.setPen( pen );
+	pa.setPen(pen);
 
 	static QString list[15] = { i18n("None"), i18n("Uniform"), i18n("Extremely Dense"),
 								i18n("Very Dense"), i18n("Somewhat Dense"), i18n("Half Dense"),
 								i18n("Somewhat Sparse"), i18n("Very Sparse"), i18n("Extremely Sparse"),
 								i18n("Horiz. Lines"), i18n("Vert. Lines"), i18n("Crossing Lines"),
 								i18n("Backward Diag. Lines"), i18n("Forward Diag. Lines"), i18n("Crossing Diag. Lines") };
 	const QColor& borderColor = (qApp->palette().color(QPalette::Base).lightness() < 128) ? Qt::white : Qt::black;
-	for (int i=0;i<15;i++) {
+	for (int i = 0; i < 15; i++) {
 		pm.fill(Qt::transparent);
-		pa.begin( &pm );
+		pa.begin(&pm);
 		pa.setPen(borderColor);
 		pa.setRenderHint(QPainter::Antialiasing);
  		pa.setBrush( QBrush(color, (Qt::BrushStyle)i) );
-		pa.drawRect( offset, offset, w - 2*offset, h - 2*offset);
+		pa.drawRect(offset, offset, w - 2*offset, h - 2*offset);
 		pa.end();
-		comboBox->addItem( QIcon(pm), list[i] );
+		comboBox->addItem(QIcon(pm), list[i]);
 	}
 
 	comboBox->setCurrentIndex(index);
 }
 
 void GuiTools::fillColorMenu(QMenu* menu, QActionGroup* actionGroup){
 	static const QString colorNames[colorsCount] = {i18n("White"), i18n("Black"),
 							i18n("Dark Red"), i18n("Red"), i18n("Light Red"),
 							i18n("Dark Green"), i18n("Green"), i18n("Light Green"),
 							i18n("Dark Blue"), i18n("Blue"), i18n("Light Blue"),
 							i18n("Dark Yellow"), i18n("Yellow"), i18n("Light Yellow"),
 							i18n("Dark Cyan"), i18n("Cyan"), i18n("Light Cyan"),
 							i18n("Dark Magenta"), i18n("Magenta"), i18n("Light Magenta"),
 							i18n("Dark Orange"), i18n("Orange"), i18n("Light Orange"),
 							i18n("Dark Grey"), i18n("Grey"), i18n("Light Grey")
 							};
 
-	QPixmap pix(16,16);
+	QPixmap pix(16, 16);
 	QPainter p(&pix);
-	for (int i=0; i<colorsCount; ++i) {
+	for (int i = 0; i < colorsCount; ++i) {
 		p.fillRect(pix.rect(), colors[i]);
 		QAction* action = new QAction(QIcon(pix), colorNames[i], actionGroup);
 		action->setCheckable(true);
 		menu->addAction(action);
 	}
 }
 
 /*!
  * Selects (checks) the action in the group \c actionGroup hat corresponds to the color \c color.
  * Unchecks the previously checked action if the color
  * was not found in the list of predefined colors.
  */
 void GuiTools::selectColorAction(QActionGroup* actionGroup, const QColor& color) {
 	int index;
-	for (index=0; index<colorsCount; ++index) {
-		if (color==colors[index]) {
+	for (index = 0; index < colorsCount; ++index) {
+		if (color == colors[index]) {
 			actionGroup->actions().at(index)->setChecked(true);
 			break;
 		}
 	}
 
-	if (index==colorsCount) {
+	if (index == colorsCount) {
 		//the color was not found in the list of predefined colors
 		// -> uncheck the previously checked action
 		QAction* checkedAction = actionGroup->checkedAction();
 		if (checkedAction)
 			checkedAction->setChecked(false);
 	}
 }
 
 QColor& GuiTools::colorFromAction(QActionGroup* actionGroup, QAction* action) {
 	int index = actionGroup->actions().indexOf(action);
-	if (index==-1 || index>=colorsCount)
+	if (index == -1 || index >= colorsCount)
 		index = 0;
 
 	return colors[index];
 }
 
 // ComboBox with colors
 // 	QImage img(16,16,QImage::Format_RGB32);
 // 	QPainter p(&img);
 // 	QRect rect = img.rect().adjusted(1,1,-1,-1);
 // 	p.fillRect(rect, Qt::red);
 // 	comboBox->setItemData(0, QPixmap::fromImage(img), Qt::DecorationRole);
diff --git a/src/kdefrontend/HistoryDialog.cpp b/src/kdefrontend/HistoryDialog.cpp
index 2d8dffa58..75628b6ab 100644
--- a/src/kdefrontend/HistoryDialog.cpp
+++ b/src/kdefrontend/HistoryDialog.cpp
@@ -1,103 +1,103 @@
 /***************************************************************************
     File                 : HistoryDialog.cpp
     Project              : LabPlot
     Description          : history dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2012-2016 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "HistoryDialog.h"
 #include <kmessagebox.h>
 #include <klocalizedstring.h>
 #include <QUndoStack>
 #include <QUndoView>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <KWindowConfig>
 #include <KSharedConfig>
 /*!
 	\class HistoryDialog
 	\brief Display the content of project's undo stack.
 
 	\ingroup kdefrontend
  */
 HistoryDialog::HistoryDialog(QWidget* parent, QUndoStack* stack, const QString& emptyLabel) : QDialog(parent),
 	m_undoStack(stack), m_clearUndoStackButton(nullptr) {
-	auto undoView = new QUndoView(stack, this);
+	auto* undoView = new QUndoView(stack, this);
 	undoView->setCleanIcon( QIcon::fromTheme("edit-clear-history") );
 	undoView->setEmptyLabel(emptyLabel);
 	undoView->setMinimumWidth(350);
 	undoView->setWhatsThis(i18n("List of all performed steps/actions.\n"
 	                            "Select an item in the list to navigate to the corresponding step."));
 
 	setWindowIcon( QIcon::fromTheme("view-history") );
 	setWindowTitle(i18nc("@title:window", "Undo/Redo History"));
 	setAttribute(Qt::WA_DeleteOnClose);
 	QDialogButtonBox* btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 	m_okButton = btnBox->button(QDialogButtonBox::Ok);
 
 	connect(btnBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &HistoryDialog::close);
 	connect(btnBox, &QDialogButtonBox::accepted, this, &HistoryDialog::accept);
 	connect(btnBox, &QDialogButtonBox::rejected, this, &HistoryDialog::reject);
 
 	if (stack->count()) {
 		m_clearUndoStackButton = new QPushButton;
 		btnBox->addButton(m_clearUndoStackButton, QDialogButtonBox::ActionRole);
 		m_clearUndoStackButton->setText(i18n("&Clear"));
 		m_clearUndoStackButton->setToolTip(i18n("Clears the undo history. Commands are not undone or redone; the state of the project remains unchanged."));
 		m_clearUndoStackButton->setIcon(QIcon::fromTheme("edit-clear"));
 		connect(m_clearUndoStackButton, &QPushButton::clicked, this, &HistoryDialog::clearUndoStack);
 	}
 
 	QFrame* line = new QFrame;
 	line->setFrameShape(QFrame::HLine);
 	line->setFrameShadow(QFrame::Sunken);
 
-	auto layout = new QVBoxLayout;
+	auto* layout = new QVBoxLayout;
 
 	layout->addWidget(undoView);
 	layout->addWidget(line);
 	layout->addWidget(btnBox);
 
 	setLayout(layout);
 	//restore saved dialog size if available
 	KConfigGroup conf(KSharedConfig::openConfig(), "HistoryDialog");
 	if (conf.exists())
 		KWindowConfig::restoreWindowSize(windowHandle(), conf);
 	else
 		resize( QSize(500, 300).expandedTo(minimumSize()) );
 }
 
 HistoryDialog::~HistoryDialog() {
 	//save dialog size
 	KConfigGroup conf(KSharedConfig::openConfig(), "HistoryDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void HistoryDialog::clearUndoStack() {
 	if (KMessageBox::questionYesNo( this,
 	                                i18n("Do you really want to clear the undo history?"),
 	                                i18n("Clear History")
 	                              ) == KMessageBox::Yes)
 		m_undoStack->clear();
 }
diff --git a/src/kdefrontend/MainWin.cpp b/src/kdefrontend/MainWin.cpp
index 80f94cf1f..072542453 100644
--- a/src/kdefrontend/MainWin.cpp
+++ b/src/kdefrontend/MainWin.cpp
@@ -1,1977 +1,1977 @@
 /***************************************************************************
     File                 : MainWin.cc
     Project              : LabPlot
     Description          : Main window of the application
     --------------------------------------------------------------------
     Copyright            : (C) 2008-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright            : (C) 2009-2018 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "MainWin.h"
 
 #include "backend/core/Project.h"
 #include "backend/core/Folder.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Workbook.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/datasources/LiveDataSource.h"
 #ifdef HAVE_LIBORIGIN
 #include "backend/datasources/projects/OriginProjectParser.h"
 #endif
 #ifdef HAVE_CANTOR_LIBS
 #include "backend/cantorWorksheet/CantorWorksheet.h"
 #endif
 #include "backend/datapicker/Datapicker.h"
 #include "backend/note/Note.h"
 #include "backend/lib/macros.h"
 
 #ifdef HAVE_MQTT
 #include "backend/datasources/MQTTClient.h"
 #endif
 
 #include "commonfrontend/core/PartMdiView.h"
 #include "commonfrontend/ProjectExplorer.h"
 #include "commonfrontend/matrix/MatrixView.h"
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
 #include "commonfrontend/worksheet/WorksheetView.h"
 #ifdef HAVE_CANTOR_LIBS
 #include "commonfrontend/cantorWorksheet/CantorWorksheetView.h"
 #endif
 #include "commonfrontend/datapicker/DatapickerView.h"
 #include "commonfrontend/datapicker/DatapickerImageView.h"
 #include "commonfrontend/note/NoteView.h"
 
 #include "kdefrontend/datasources/ImportFileDialog.h"
 #include "kdefrontend/datasources/ImportProjectDialog.h"
 #include "kdefrontend/datasources/ImportSQLDatabaseDialog.h"
 #include "kdefrontend/dockwidgets/ProjectDock.h"
 #include "kdefrontend/HistoryDialog.h"
 #include "kdefrontend/SettingsDialog.h"
 #include "kdefrontend/GuiObserver.h"
 #include "kdefrontend/widgets/FITSHeaderEditDialog.h"
 
 #include <QMdiArea>
 #include <QMenu>
 #include <QDockWidget>
 #include <QStackedWidget>
 #include <QUndoStack>
 #include <QCloseEvent>
 #include <QFileDialog>
 #include <QMimeData>
 #include <QElapsedTimer>
 #include <QHash>
 #include <QStatusBar>
 #include <QTimeLine>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KStandardAction>
 #include <kxmlguifactory.h>
 #include <KMessageBox>
 #include <KToolBar>
 #include <KLocalizedString>
 #include <KFilterDev>
 #include <KRecentFilesAction>
 #include <KActionMenu>
 #include <KColorScheme>
 #include <KColorSchemeManager>
 
 #ifdef HAVE_CANTOR_LIBS
 #include <cantor/backend.h>
 #endif
 
 /*!
 \class MainWin
 \brief Main application window.
 
 \ingroup kdefrontend
 */
 MainWin::MainWin(QWidget *parent, const QString& filename)
 	: KXmlGuiWindow(parent),
 	  m_currentSubWindow(nullptr),
 	  m_project(nullptr),
 	  m_aspectTreeModel(nullptr),
 	  m_projectExplorer(nullptr),
 	  m_projectExplorerDock(nullptr),
 	  m_propertiesDock(nullptr),
 	  m_currentAspect(nullptr),
 	  m_currentFolder(nullptr),
 	  m_suppressCurrentSubWindowChangedEvent(false),
 	  m_closing(false),
 	  m_autoSaveActive(false),
 	  m_visibilityMenu(nullptr),
 	  m_newMenu(nullptr),
 	  m_editMenu(nullptr),
 	  axisDock(nullptr),
 	  notesDock(nullptr),
 	  cartesianPlotDock(nullptr),
 	  cartesianPlotLegendDock(nullptr),
 	  columnDock(nullptr),
 	  m_liveDataDock(nullptr),
 	  matrixDock(nullptr),
 	  spreadsheetDock(nullptr),
 	  projectDock(nullptr),
 	  xyCurveDock(nullptr),
 	  xyEquationCurveDock(nullptr),
 	  xyDataReductionCurveDock(nullptr),
 	  xyDifferentiationCurveDock(nullptr),
 	  xyIntegrationCurveDock(nullptr),
 	  xyInterpolationCurveDock(nullptr),
 	  xySmoothCurveDock(nullptr),
 	  xyFitCurveDock(nullptr),
 	  xyFourierFilterCurveDock(nullptr),
 	  xyFourierTransformCurveDock(nullptr),
 	  xyConvolutionCurveDock(nullptr),
 	  xyCorrelationCurveDock(nullptr),
 	  histogramDock(nullptr),
 	  worksheetDock(nullptr),
 	  textLabelDock(nullptr),
 	  customPointDock(nullptr),
 	  datapickerImageDock(nullptr),
 	  datapickerCurveDock(nullptr),
 #ifdef HAVE_CANTOR_LIBS
 	  cantorWorksheetDock(nullptr),
 #endif
 	  m_guiObserver(nullptr) {
 
 	initGUI(filename);
 	setAcceptDrops(true);
 
 	//restore the geometry
 	KConfigGroup group = KSharedConfig::openConfig()->group("MainWin");
 	restoreGeometry(group.readEntry("geometry", QByteArray()));
 }
 
 MainWin::~MainWin() {
 	//save the recent opened files
 	m_recentProjectsAction->saveEntries( KSharedConfig::openConfig()->group("Recent Files") );
 	KConfigGroup group = KSharedConfig::openConfig()->group("MainWin");
 	group.writeEntry("geometry", saveGeometry());
 	KSharedConfig::openConfig()->sync();
 
 	if (m_project != nullptr) {
 		m_mdiArea->closeAllSubWindows();
 		disconnect(m_project, nullptr, this, nullptr);
 		delete m_project;
 	}
 
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 
 	if (m_guiObserver)
 		delete m_guiObserver;
 }
 
 void MainWin::showPresenter() {
 	Worksheet* w = activeWorksheet();
 	if (w) {
-		auto view = dynamic_cast<WorksheetView*>(w->view());
+		auto* view = dynamic_cast<WorksheetView*>(w->view());
 		view->presenterMode();
 	} else {
 		//currently active object is not a worksheet but we're asked to start in the presenter mode
 		//determine the first available worksheet and show it in the presenter mode
 		QVector<Worksheet*> worksheets = m_project->children<Worksheet>();
-		if (worksheets.size()>0) {
-			auto view = qobject_cast<WorksheetView*>(worksheets.first()->view());
+		if (worksheets.size() > 0) {
+			auto* view = qobject_cast<WorksheetView*>(worksheets.first()->view());
 			view->presenterMode();
 		} else {
 			QMessageBox::information(this, i18n("Presenter Mode"),
 			                         i18n("No worksheets are available in the project. The presenter mode will not be started."));
 		}
 	}
 }
 
 AspectTreeModel* MainWin::model() const {
 	return m_aspectTreeModel;
 }
 
 Project* MainWin::project() const {
 	return m_project;
 }
 
 void MainWin::initGUI(const QString& fileName) {
 	m_mdiArea = new QMdiArea;
 	setCentralWidget(m_mdiArea);
 	connect(m_mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)),
 	        this, SLOT(handleCurrentSubWindowChanged(QMdiSubWindow*)));
 
 	statusBar()->showMessage(i18nc("%1 is the LabPlot version", "Welcome to LabPlot %1", QLatin1String(LVERSION)));
 	initActions();
 #ifdef Q_OS_DARWIN
 	setupGUI(Default, QLatin1String("/Applications/labplot2.app/Contents/Resources/labplot2ui.rc"));
 #else
 	setupGUI(Default, QLatin1String("labplot2ui.rc"));
 #endif
 
 	//all toolbars created via the KXMLGUI framework are locked on default:
 	// * on the very first program start, unlock all toolbars
 	// * on later program starts, set stored lock status
 	//Furthermore, we want to show icons only after the first program start.
 	KConfigGroup groupMain = KSharedConfig::openConfig()->group("MainWindow");
 	if (groupMain.exists()) {
 		//KXMLGUI framework automatically stores "Disabled" for the key "ToolBarsMovable"
 		//in case the toolbars are locked -> load this value
 		const QString& str = groupMain.readEntry(QLatin1String("ToolBarsMovable"), "");
 		bool locked = (str == QLatin1String("Disabled"));
 		KToolBar::setToolBarsLocked(locked);
 	} else {
 		//first start
 		KToolBar::setToolBarsLocked(false);
 
 		//show icons only
 		for (auto* container : factory()->containers(QLatin1String("ToolBar"))) {
-			auto toolbar = dynamic_cast<QToolBar*>(container);
+			auto* toolbar = dynamic_cast<QToolBar*>(container);
 			if (toolbar)
 				toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
 		}
 	}
 
 	initMenus();
 
-	auto mainToolBar = qobject_cast<QToolBar*>(factory()->container("main_toolbar", this));
+	auto* mainToolBar = qobject_cast<QToolBar*>(factory()->container("main_toolbar", this));
 	if (!mainToolBar) {
 		QMessageBox::critical(this, i18n("GUI configuration file not found"), i18n("labplot2ui.rc file was not found. Please check your installation."));
 		//TODO: the application is not really usable if the rc file was not found. We should quit the application. The following line crashes
 		//the application because of the splash screen. We need to find another solution.
 // 		QMetaObject::invokeMethod(this, "close", Qt::QueuedConnection); //call close as soon as we enter the eventloop
 		return;
 	}
-	auto tbImport = new QToolButton(mainToolBar);
+	auto* tbImport = new QToolButton(mainToolBar);
 	tbImport->setPopupMode(QToolButton::MenuButtonPopup);
 	tbImport->setMenu(m_importMenu);
 	tbImport->setDefaultAction(m_importFileAction);
 	mainToolBar->addWidget(tbImport);
 
 	qobject_cast<QMenu*>(factory()->container("import", this))->setIcon(QIcon::fromTheme("document-import"));
 	setWindowIcon(QIcon::fromTheme("LabPlot2", QGuiApplication::windowIcon()));
 	setAttribute( Qt::WA_DeleteOnClose );
 
 	//make the status bar of a fixed size in order to avoid height changes when placing a ProgressBar there.
 	QFont font;
 	font.setFamily(font.defaultFamily());
 	QFontMetrics fm(font);
 	statusBar()->setFixedHeight(fm.height()+5);
 
 	//load recently used projects
 	m_recentProjectsAction->loadEntries( KSharedConfig::openConfig()->group("Recent Files") );
 
 	//set the view mode of the mdi area
 	KConfigGroup group = KSharedConfig::openConfig()->group( "Settings_General" );
 	int viewMode = group.readEntry("ViewMode", 0);
 	if (viewMode == 1) {
 		m_mdiArea->setViewMode(QMdiArea::TabbedView);
 		int tabPosition = group.readEntry("TabPosition", 0);
 		m_mdiArea->setTabPosition(QTabWidget::TabPosition(tabPosition));
 		m_mdiArea->setTabsClosable(true);
 		m_mdiArea->setTabsMovable(true);
 		m_tileWindows->setVisible(false);
 		m_cascadeWindows->setVisible(false);
 	}
 
 	//auto-save
 	m_autoSaveActive = group.readEntry<bool>("AutoSave", false);
 	int interval = group.readEntry("AutoSaveInterval", 1);
 	interval = interval*60*1000;
 	m_autoSaveTimer.setInterval(interval);
 	connect(&m_autoSaveTimer, SIGNAL(timeout()), this, SLOT(autoSaveProject()));
 
 	if (!fileName.isEmpty()) {
 #ifdef HAVE_LIBORIGIN
 		if (Project::isLabPlotProject(fileName) || OriginProjectParser::isOriginProject(fileName)) {
 #else
 		if (Project::isLabPlotProject(fileName)) {
 #endif
 			QTimer::singleShot(0, this, [=] () { openProject(fileName); });
 		} else {
 			newProject();
 			QTimer::singleShot(0, this, [=] () { importFileDialog(fileName); });
 		}
 
 	} else {
 		//There is no file to open. Depending on the settings do nothing,
 		//create a new project or open the last used project.
 		int load = group.readEntry("LoadOnStart", 0);
 		if (load == 1)   //create new project
 			newProject();
 		else if (load == 2) { //create new project with a worksheet
 			newProject();
 			newWorksheet();
 		} else if (load == 3) { //open last used project
 			if (!m_recentProjectsAction->urls().isEmpty()) {
 				QDEBUG("TO OPEN m_recentProjectsAction->urls() =" << m_recentProjectsAction->urls().first());
 				openRecentProject( m_recentProjectsAction->urls().constFirst() );
 			}
 		}
 	}
 	updateGUIOnProjectChanges();
 }
 
 void MainWin::initActions() {
 	// ******************** File-menu *******************************
 	//add some standard actions
 	KStandardAction::openNew(this, SLOT(newProject()),actionCollection());
 	KStandardAction::open(this, SLOT(openProject()),actionCollection());
 	m_recentProjectsAction = KStandardAction::openRecent(this, SLOT(openRecentProject(QUrl)),actionCollection());
 	m_closeAction = KStandardAction::close(this, SLOT(closeProject()),actionCollection());
 	actionCollection()->setDefaultShortcut(m_closeAction, QKeySequence()); //remove the shortcut, QKeySequence::Close will be used for closing sub-windows
 	m_saveAction = KStandardAction::save(this, SLOT(saveProject()),actionCollection());
 	m_saveAsAction = KStandardAction::saveAs(this, SLOT(saveProjectAs()),actionCollection());
 	m_printAction = KStandardAction::print(this, SLOT(print()),actionCollection());
 	m_printPreviewAction = KStandardAction::printPreview(this, SLOT(printPreview()),actionCollection());
 	KStandardAction::fullScreen(this, SLOT(toggleFullScreen()), this, actionCollection());
 	//New Folder/Workbook/Spreadsheet/Matrix/Worksheet/Datasources
 	m_newWorkbookAction = new QAction(QIcon::fromTheme("labplot-workbook-new"),i18n("Workbook"),this);
 	actionCollection()->addAction("new_workbook", m_newWorkbookAction);
 	connect(m_newWorkbookAction, SIGNAL(triggered()), SLOT(newWorkbook()));
 
 	m_newDatapickerAction = new QAction(QIcon::fromTheme("color-picker-black"), i18n("Datapicker"), this);
 	actionCollection()->addAction("new_datapicker", m_newDatapickerAction);
 	connect(m_newDatapickerAction, SIGNAL(triggered()), SLOT(newDatapicker()));
 
 	m_newSpreadsheetAction = new QAction(QIcon::fromTheme("labplot-spreadsheet-new"),i18n("Spreadsheet"),this);
 
 // 	m_newSpreadsheetAction->setShortcut(Qt::CTRL+Qt::Key_Equal);
 	actionCollection()->addAction("new_spreadsheet", m_newSpreadsheetAction);
 	connect(m_newSpreadsheetAction, SIGNAL(triggered()), SLOT(newSpreadsheet()));
 
 	m_newMatrixAction = new QAction(QIcon::fromTheme("labplot-matrix-new"),i18n("Matrix"),this);
 // 	m_newMatrixAction->setShortcut(Qt::CTRL+Qt::Key_Equal);
 	actionCollection()->addAction("new_matrix", m_newMatrixAction);
 	connect(m_newMatrixAction, SIGNAL(triggered()), SLOT(newMatrix()));
 
 	m_newWorksheetAction= new QAction(QIcon::fromTheme("labplot-worksheet-new"),i18n("Worksheet"),this);
 // 	m_newWorksheetAction->setShortcut(Qt::ALT+Qt::Key_X);
 	actionCollection()->addAction("new_worksheet", m_newWorksheetAction);
 	connect(m_newWorksheetAction, SIGNAL(triggered()), SLOT(newWorksheet()));
 
 	m_newNotesAction= new QAction(QIcon::fromTheme("document-new"),i18n("Note"),this);
 	actionCollection()->addAction("new_notes", m_newNotesAction);
 	connect(m_newNotesAction, SIGNAL(triggered()), SLOT(newNotes()));
 
 // 	m_newScriptAction = new QAction(QIcon::fromTheme("insert-text"),i18n("Note/Script"),this);
 // 	actionCollection()->addAction("new_script", m_newScriptAction);
 // 	connect(m_newScriptAction, SIGNAL(triggered()),SLOT(newScript()));
 
 	m_newFolderAction = new QAction(QIcon::fromTheme("folder-new"),i18n("Folder"),this);
 	actionCollection()->addAction("new_folder", m_newFolderAction);
 	connect(m_newFolderAction, SIGNAL(triggered()), SLOT(newFolder()));
 
 	//"New file datasources"
 	m_newLiveDataSourceAction = new QAction(QIcon::fromTheme("application-octet-stream"),i18n("Live Data Source"),this);
 	actionCollection()->addAction("new_live_datasource", m_newLiveDataSourceAction);
 	connect(m_newLiveDataSourceAction, SIGNAL(triggered()), this, SLOT(newLiveDataSourceActionTriggered()));
 
 	//Import/Export
 	m_importFileAction = new QAction(QIcon::fromTheme("document-import"), i18n("From File"), this);
 	actionCollection()->setDefaultShortcut(m_importFileAction, Qt::CTRL+Qt::SHIFT+Qt::Key_I);
 	actionCollection()->addAction("import_file", m_importFileAction);
 	connect(m_importFileAction, SIGNAL(triggered()), SLOT(importFileDialog()));
 
 	m_importSqlAction = new QAction(QIcon::fromTheme("document-import-database"), i18n("From SQL Database"), this);
 	actionCollection()->addAction("import_sql", m_importSqlAction);
 	connect(m_importSqlAction, SIGNAL(triggered()),SLOT(importSqlDialog()));
 
 	m_importLabPlotAction = new QAction(QIcon::fromTheme("document-import"), i18n("LabPlot Project"), this);
 	actionCollection()->addAction("import_labplot", m_importLabPlotAction);
 	connect(m_importLabPlotAction, SIGNAL(triggered()),SLOT(importProjectDialog()));
 
 #ifdef HAVE_LIBORIGIN
 	m_importOpjAction = new QAction(QIcon::fromTheme("document-import-database"), i18n("Origin Project (OPJ)"), this);
 	actionCollection()->addAction("import_opj", m_importOpjAction);
 	connect(m_importOpjAction, SIGNAL(triggered()),SLOT(importProjectDialog()));
 #endif
 
 	m_exportAction = new QAction(QIcon::fromTheme("document-export"), i18n("Export"), this);
 	actionCollection()->setDefaultShortcut(m_exportAction, Qt::CTRL+Qt::SHIFT+Qt::Key_E);
 	actionCollection()->addAction("export", m_exportAction);
 	connect(m_exportAction, SIGNAL(triggered()), SLOT(exportDialog()));
 
 	m_editFitsFileAction = new QAction(i18n("FITS Metadata Editor"), this);
 	actionCollection()->addAction("edit_fits", m_editFitsFileAction);
 	connect(m_editFitsFileAction, SIGNAL(triggered()), SLOT(editFitsFileDialog()));
 
 	// Edit
 	//Undo/Redo-stuff
 	m_undoAction = KStandardAction::undo(this, SLOT(undo()), actionCollection());
 	m_redoAction = KStandardAction::redo(this, SLOT(redo()), actionCollection());
 
 	m_historyAction = new QAction(QIcon::fromTheme("view-history"), i18n("Undo/Redo History"),this);
 	actionCollection()->addAction("history", m_historyAction);
 	connect(m_historyAction, SIGNAL(triggered()), SLOT(historyDialog()));
 
 	// TODO: more menus
 	//  Appearance
 	// Analysis: see WorksheetView.cpp
 	// Drawing
 	// Script
 
 	//Windows
 	QAction* action  = new QAction(i18n("&Close"), this);
 	actionCollection()->setDefaultShortcut(action, QKeySequence::Close);
 	action->setStatusTip(i18n("Close the active window"));
 	actionCollection()->addAction("close window", action);
 	connect(action, SIGNAL(triggered()), m_mdiArea, SLOT(closeActiveSubWindow()));
 
 	action = new QAction(i18n("Close &All"), this);
 	action->setStatusTip(i18n("Close all the windows"));
 	actionCollection()->addAction("close all windows", action);
 	connect(action, SIGNAL(triggered()), m_mdiArea, SLOT(closeAllSubWindows()));
 
 	m_tileWindows = new QAction(i18n("&Tile"), this);
 	m_tileWindows->setStatusTip(i18n("Tile the windows"));
 	actionCollection()->addAction("tile windows", m_tileWindows);
 	connect(m_tileWindows, SIGNAL(triggered()), m_mdiArea, SLOT(tileSubWindows()));
 
 	m_cascadeWindows = new QAction(i18n("&Cascade"), this);
 	m_cascadeWindows->setStatusTip(i18n("Cascade the windows"));
 	actionCollection()->addAction("cascade windows", m_cascadeWindows);
 	connect(m_cascadeWindows, SIGNAL(triggered()), m_mdiArea, SLOT(cascadeSubWindows()));
 	action = new QAction(QIcon::fromTheme("go-next-view"), i18n("Ne&xt"), this);
 	actionCollection()->setDefaultShortcut(action, QKeySequence::NextChild);
 	action->setStatusTip(i18n("Move the focus to the next window"));
 	actionCollection()->addAction("next window", action);
 	connect(action, SIGNAL(triggered()), m_mdiArea, SLOT(activateNextSubWindow()));
 
 	action = new QAction(QIcon::fromTheme("go-previous-view"), i18n("Pre&vious"), this);
 	actionCollection()->setDefaultShortcut(action, QKeySequence::PreviousChild);
 	action->setStatusTip(i18n("Move the focus to the previous window"));
 	actionCollection()->addAction("previous window", action);
 	connect(action, SIGNAL(triggered()), m_mdiArea, SLOT(activatePreviousSubWindow()));
 
 	//"Standard actions"
 	KStandardAction::preferences(this, SLOT(settingsDialog()), actionCollection());
 	KStandardAction::quit(this, SLOT(close()), actionCollection());
 
 	//Actions for window visibility
-	auto windowVisibilityActions = new QActionGroup(this);
+	auto* windowVisibilityActions = new QActionGroup(this);
 	windowVisibilityActions->setExclusive(true);
 
 	m_visibilityFolderAction = new QAction(QIcon::fromTheme("folder"), i18n("Current &Folder Only"), windowVisibilityActions);
 	m_visibilityFolderAction->setCheckable(true);
 	m_visibilityFolderAction->setData(Project::folderOnly);
 
 	m_visibilitySubfolderAction = new QAction(QIcon::fromTheme("folder-documents"), i18n("Current Folder and &Subfolders"), windowVisibilityActions);
 	m_visibilitySubfolderAction->setCheckable(true);
 	m_visibilitySubfolderAction->setData(Project::folderAndSubfolders);
 
 	m_visibilityAllAction = new QAction(i18n("&All"), windowVisibilityActions);
 	m_visibilityAllAction->setCheckable(true);
 	m_visibilityAllAction->setData(Project::allMdiWindows);
 
 	connect(windowVisibilityActions, SIGNAL(triggered(QAction*)), this, SLOT(setMdiWindowVisibility(QAction*)));
 
 	//Actions for hiding/showing the dock widgets
-	auto docksActions = new QActionGroup(this);
+	auto* docksActions = new QActionGroup(this);
 	docksActions->setExclusive(false);
 
 	m_toggleProjectExplorerDockAction = new QAction(QIcon::fromTheme("view-list-tree"), i18n("Project Explorer"), docksActions);
 	m_toggleProjectExplorerDockAction->setCheckable(true);
 	m_toggleProjectExplorerDockAction->setChecked(true);
 	actionCollection()->addAction("toggle_project_explorer_dock", m_toggleProjectExplorerDockAction);
 
 	m_togglePropertiesDockAction = new QAction(QIcon::fromTheme("view-list-details"), i18n("Properties Explorer"), docksActions);
 	m_togglePropertiesDockAction->setCheckable(true);
 	m_togglePropertiesDockAction->setChecked(true);
 	actionCollection()->addAction("toggle_properties_explorer_dock", m_togglePropertiesDockAction);
 
 	connect(docksActions, SIGNAL(triggered(QAction*)), this, SLOT(toggleDockWidget(QAction*)));
 }
 
 void MainWin::initMenus() {
 	//menu for adding new aspects
 	m_newMenu = new QMenu(i18n("Add New"), this);
 	m_newMenu->setIcon(QIcon::fromTheme("document-new"));
 	m_newMenu->addAction(m_newFolderAction);
 	m_newMenu->addAction(m_newWorkbookAction);
 	m_newMenu->addAction(m_newSpreadsheetAction);
 	m_newMenu->addAction(m_newMatrixAction);
 	m_newMenu->addAction(m_newWorksheetAction);
 	m_newMenu->addAction(m_newNotesAction);
 	m_newMenu->addAction(m_newDatapickerAction);
 	m_newMenu->addSeparator();
 	m_newMenu->addAction(m_newLiveDataSourceAction);
 
 	//import menu
 	m_importMenu = new QMenu(this);
 	m_importMenu->setIcon(QIcon::fromTheme("document-import"));
 	m_importMenu ->addAction(m_importFileAction);
 	m_importMenu ->addAction(m_importSqlAction);
 	m_importMenu->addSeparator();
 	m_importMenu->addAction(m_importLabPlotAction);
 #ifdef HAVE_LIBORIGIN
 	m_importMenu ->addAction(m_importOpjAction);
 #endif
 
 #ifdef HAVE_CANTOR_LIBS
 	m_newMenu->addSeparator();
 	m_newCantorWorksheetMenu = new QMenu(i18n("CAS Worksheet"));
 	m_newCantorWorksheetMenu->setIcon(QIcon::fromTheme("archive-insert"));
 
 	//"Adding Cantor backends to menue and context menu"
 	QStringList m_availableBackend = Cantor::Backend::listAvailableBackends();
 	if(m_availableBackend.count() > 0) {
 		unplugActionList(QLatin1String("backends_list"));
 		QList<QAction*> newBackendActions;
 		for (Cantor::Backend* backend : Cantor::Backend::availableBackends()) {
 			if (!backend->isEnabled()) continue;
 			QAction* action = new QAction(QIcon::fromTheme(backend->icon()), backend->name(),this);
 			action->setData(backend->name());
 			newBackendActions << action;
 			m_newCantorWorksheetMenu->addAction(action);
 		}
 
 		connect(m_newCantorWorksheetMenu, SIGNAL(triggered(QAction*)), this, SLOT(newCantorWorksheet(QAction*)));
 		plugActionList(QLatin1String("backends_list"), newBackendActions);
 	}
 	m_newMenu->addMenu(m_newCantorWorksheetMenu);
 #else
 	delete this->guiFactory()->container("cas_worksheet", this);
 	delete this->guiFactory()->container("new_cas_worksheet", this);
 	delete this->guiFactory()->container("cas_worksheet_toolbar", this);
 #endif
 
 	//menu subwindow visibility policy
 	m_visibilityMenu = new QMenu(i18n("Window Visibility Policy"), this);
 	m_visibilityMenu->setIcon(QIcon::fromTheme("window-duplicate"));
 	m_visibilityMenu ->addAction(m_visibilityFolderAction);
 	m_visibilityMenu ->addAction(m_visibilitySubfolderAction);
 	m_visibilityMenu ->addAction(m_visibilityAllAction);
 
 	//menu for editing files
 	m_editMenu = new QMenu(i18n("Edit"), this);
 	m_editMenu->addAction(m_editFitsFileAction);
 
 	KColorSchemeManager schemeManager;
 	KActionMenu* schemesMenu = schemeManager.createSchemeSelectionMenu(i18n("Color Theme"), this);
 	schemesMenu->menu()->setTitle(i18n("Color Theme"));
 	schemesMenu->setIcon(QIcon::fromTheme(QStringLiteral("preferences-desktop-color")));
 
 	QMenu* settingsMenu = dynamic_cast<QMenu*>(factory()->container("settings", this));
 	if (settingsMenu)
 		settingsMenu->insertMenu(settingsMenu->actions().constFirst(), schemesMenu->menu());
 
 	//set the action for the current color scheme checked
 	KConfigGroup generalGlobalsGroup = KSharedConfig::openConfig(QLatin1String("kdeglobals"))->group("General");
 	QString defaultSchemeName = generalGlobalsGroup.readEntry("ColorScheme", QStringLiteral("Breeze"));
 	KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Settings_General"));
 	QString schemeName = group.readEntry("ColorScheme", defaultSchemeName);
 
 	for (auto* action : schemesMenu->menu()->actions()) {
 		if (action->text() == schemeName) {
 			action->setChecked(true);
 			break;
 		}
 	}
 
 	connect(schemesMenu->menu(), &QMenu::triggered, this, &MainWin::colorSchemeChanged);
 }
 
 void MainWin::colorSchemeChanged(QAction* action) {
 	QString schemeName = KLocalizedString::removeAcceleratorMarker(action->text());
 
 	//background of the mdi area is not updated on theme changes, do it here.
 	KColorSchemeManager schemeManager;
 	QModelIndex index = schemeManager.indexForScheme(schemeName);
 	const QPalette& palette = KColorScheme::createApplicationPalette( KSharedConfig::openConfig(index.data(Qt::UserRole).toString()) );
 	const QBrush& brush = palette.brush(QPalette::Dark);
 	m_mdiArea->setBackground(brush);
 
 	//save the selected color scheme
 	KConfigGroup group = KSharedConfig::openConfig()->group(QLatin1String("Settings_General"));
 	group.writeEntry("ColorScheme", schemeName);
 	group.sync();
 }
 
 /*!
 	Asks to save the project if it was modified.
 	\return \c true if the project still needs to be saved ("cancel" clicked), \c false otherwise.
  */
 bool MainWin::warnModified() {
 	if (m_project->hasChanged()) {
 		int want_save = KMessageBox::warningYesNoCancel( this,
 		                i18n("The current project %1 has been modified. Do you want to save it?", m_project->name()),
 		                i18n("Save Project"));
 		switch (want_save) {
 		case KMessageBox::Yes:
 			return !saveProject();
 		case KMessageBox::No:
 			break;
 		case KMessageBox::Cancel:
 			return true;
 		}
 	}
 
 	return false;
 }
 
 /*!
  * updates the state of actions, menus and toolbars (enabled or disabled)
  * on project changes (project closes and opens)
  */
 void MainWin::updateGUIOnProjectChanges() {
 	if (m_closing)
 		return;
 
 	KXMLGUIFactory* factory = this->guiFactory();
 	if (factory->container("worksheet", this) == nullptr) {
 		//no worksheet menu found, most probably labplot2ui.rc
 		//was not properly installed -> return here in order not to crash
 		return;
 	}
 
 	//disable all menus if there is no project
 	bool b = (m_project == nullptr);
 	m_saveAction->setEnabled(!b);
 	m_saveAsAction->setEnabled(!b);
 	m_printAction->setEnabled(!b);
 	m_printPreviewAction->setEnabled(!b);
 	m_importFileAction->setEnabled(!b);
 	m_importSqlAction->setEnabled(!b);
 #ifdef HAVE_LIBORIGIN
 	m_importOpjAction->setEnabled(!b);
 #endif
 	m_exportAction->setEnabled(!b);
 	m_newWorkbookAction->setEnabled(!b);
 	m_newSpreadsheetAction->setEnabled(!b);
 	m_newMatrixAction->setEnabled(!b);
 	m_newWorksheetAction->setEnabled(!b);
 	m_newDatapickerAction->setEnabled(!b);
 	m_closeAction->setEnabled(!b);
 	m_toggleProjectExplorerDockAction->setEnabled(!b);
 	m_togglePropertiesDockAction->setEnabled(!b);
 
 	if (!m_mdiArea->currentSubWindow()) {
 		factory->container("spreadsheet", this)->setEnabled(false);
 		factory->container("matrix", this)->setEnabled(false);
 		factory->container("worksheet", this)->setEnabled(false);
 		factory->container("analysis", this)->setEnabled(false);
 		factory->container("datapicker", this)->setEnabled(false);
 		factory->container("spreadsheet_toolbar", this)->hide();
 		factory->container("worksheet_toolbar", this)->hide();
 		factory->container("cartesian_plot_toolbar", this)->hide();
 // 		factory->container("histogram_toolbar",this)->hide();
 // 		factory->container("barchart_toolbar",this)->hide();
 		factory->container("datapicker_toolbar", this)->hide();
 #ifdef HAVE_CANTOR_LIBS
 		factory->container("cas_worksheet", this)->setEnabled(false);
 		factory->container("cas_worksheet_toolbar", this)->hide();
 #endif
 	}
 
 	factory->container("new", this)->setEnabled(!b);
 	factory->container("edit", this)->setEnabled(!b);
 	factory->container("import", this)->setEnabled(!b);
 
 	if (b)
 		setCaption("LabPlot2");
 	else
 		setCaption(m_project->name());
 
 	// undo/redo actions are disabled in both cases - when the project is closed or opened
 	m_undoAction->setEnabled(false);
 	m_redoAction->setEnabled(false);
 }
 
 /*
  * updates the state of actions, menus and toolbars (enabled or disabled)
  * depending on the currently active window (worksheet or spreadsheet).
  */
 void MainWin::updateGUI() {
 	if (m_project->isLoading())
 		return;
 
 	if (m_closing)
 		return;
 
 	KXMLGUIFactory* factory = this->guiFactory();
 	if (factory->container("worksheet", this) == nullptr) {
 		//no worksheet menu found, most probably labplot2ui.rc
 		//was not properly installed -> return here in order not to crash
 		return;
 	}
 
 	if (!m_mdiArea->currentSubWindow()) {
 		factory->container("spreadsheet", this)->setEnabled(false);
 		factory->container("matrix", this)->setEnabled(false);
 		factory->container("worksheet", this)->setEnabled(false);
 		factory->container("analysis", this)->setEnabled(false);
 		factory->container("datapicker", this)->setEnabled(false);
 		factory->container("spreadsheet_toolbar", this)->hide();
 		factory->container("worksheet_toolbar", this)->hide();
 // 		factory->container("histogram_toolbar",this)->hide();
 // 		factory->container("barchart_toolbar",this)->hide();
 		factory->container("cartesian_plot_toolbar", this)->hide();
 		factory->container("datapicker_toolbar", this)->hide();
 #ifdef HAVE_CANTOR_LIBS
 		factory->container("cas_worksheet", this)->setEnabled(false);
 		factory->container("cas_worksheet_toolbar", this)->hide();
 #endif
 		return;
 	}
 
 
 	//Handle the Worksheet-object
 	Worksheet* w = this->activeWorksheet();
 	if (w != nullptr) {
 		//enable worksheet related menus
 		factory->container("worksheet", this)->setEnabled(true);
 		factory->container("analysis", this)->setEnabled(true);
 //TODO 		factory->container("drawing", this)->setEnabled(true);
 
 		//disable spreadsheet and matrix related menus
 		factory->container("spreadsheet", this)->setEnabled(false);
 		factory->container("matrix", this)->setEnabled(false);
 
 		//populate worksheet menu
-		auto view = qobject_cast<WorksheetView*>(w->view());
-		auto menu = qobject_cast<QMenu*>(factory->container("worksheet", this));
+		auto* view = qobject_cast<WorksheetView*>(w->view());
+		auto* menu = qobject_cast<QMenu*>(factory->container("worksheet", this));
 		menu->clear();
 		view->createContextMenu(menu);
 
 		//populate analysis menu
 		menu = qobject_cast<QMenu*>(factory->container("analysis", this));
 		menu->clear();
 		view->createAnalysisMenu(menu);
 
 		//populate worksheet-toolbar
-		auto toolbar = qobject_cast<QToolBar*>(factory->container("worksheet_toolbar", this));
+		auto* toolbar = qobject_cast<QToolBar*>(factory->container("worksheet_toolbar", this));
 		toolbar->clear();
 		view->fillToolBar(toolbar);
 		toolbar->setVisible(true);
 		toolbar->setEnabled(true);
 
 		//populate the toolbar for cartesian plots
 		toolbar = qobject_cast<QToolBar*>(factory->container("cartesian_plot_toolbar", this));
 		toolbar->clear();
 		view->fillCartesianPlotToolBar(toolbar);
 		toolbar->setVisible(true);
 		toolbar->setEnabled(true);
 
 		//hide the spreadsheet toolbar
 		factory->container("spreadsheet_toolbar", this)->setVisible(false);
 	} else {
 		factory->container("worksheet", this)->setEnabled(false);
 		factory->container("analysis", this)->setEnabled(false);
 //		factory->container("drawing", this)->setEnabled(false);
 		factory->container("worksheet_toolbar", this)->setEnabled(false);
 		factory->container("cartesian_plot_toolbar", this)->setEnabled(false);
 	}
 
 	//Handle the Spreadsheet-object
-	const  Spreadsheet* spreadsheet = this->activeSpreadsheet();
+	const  auto* spreadsheet = this->activeSpreadsheet();
 	if (spreadsheet) {
 		//enable spreadsheet related menus
 		factory->container("spreadsheet", this)->setEnabled(true);
 
 		//populate spreadsheet-menu
-		auto view = qobject_cast<SpreadsheetView*>(spreadsheet->view());
-		auto menu = qobject_cast<QMenu*>(factory->container("spreadsheet", this));
+		auto* view = qobject_cast<SpreadsheetView*>(spreadsheet->view());
+		auto* menu = qobject_cast<QMenu*>(factory->container("spreadsheet", this));
 		menu->clear();
 		view->createContextMenu(menu);
 
 		//populate spreadsheet-toolbar
-		auto toolbar = qobject_cast<QToolBar*>(factory->container("spreadsheet_toolbar", this));
+		auto* toolbar = qobject_cast<QToolBar*>(factory->container("spreadsheet_toolbar", this));
 		toolbar->clear();
 		view->fillToolBar(toolbar);
 		toolbar->setVisible(true);
 		toolbar->setEnabled(true);
 	} else {
 		factory->container("spreadsheet", this)->setEnabled(false);
 		factory->container("spreadsheet_toolbar", this)->setEnabled(false);
 	}
 
 	//Handle the Matrix-object
 	const  Matrix* matrix = this->activeMatrix();
 	if (matrix) {
 		factory->container("matrix", this)->setEnabled(true);
 
 		//populate matrix-menu
-		auto view = qobject_cast<MatrixView*>(matrix->view());
-		auto menu = qobject_cast<QMenu*>(factory->container("matrix", this));
+		auto* view = qobject_cast<MatrixView*>(matrix->view());
+		auto* menu = qobject_cast<QMenu*>(factory->container("matrix", this));
 		menu->clear();
 		view->createContextMenu(menu);
 	} else
 		factory->container("matrix", this)->setEnabled(false);
 
 #ifdef HAVE_CANTOR_LIBS
 	CantorWorksheet* cantorworksheet = this->activeCantorWorksheet();
 	if(cantorworksheet) {
 		// enable Cantor Worksheet related menus
 		factory->container("cas_worksheet", this)->setEnabled(true);
-		auto view = qobject_cast<CantorWorksheetView*>(cantorworksheet->view());
-		auto menu = qobject_cast<QMenu*>(factory->container("cas_worksheet", this));
+		auto* view = qobject_cast<CantorWorksheetView*>(cantorworksheet->view());
+		auto* menu = qobject_cast<QMenu*>(factory->container("cas_worksheet", this));
 		menu->clear();
 		view->createContextMenu(menu);
-		auto toolbar = qobject_cast<QToolBar*>(factory->container("cas_worksheet_toolbar", this));
+		auto* toolbar = qobject_cast<QToolBar*>(factory->container("cas_worksheet_toolbar", this));
 		toolbar->setVisible(true);
 		toolbar->clear();
 		view->fillToolBar(toolbar);
 	} else {
 		//no Cantor worksheet selected -> deactivate Cantor worksheet related menu and toolbar
 		factory->container("cas_worksheet", this)->setEnabled(false);
 		factory->container("cas_worksheet_toolbar", this)->setVisible(false);
 	}
 #endif
 
 	const Datapicker* datapicker = this->activeDatapicker();
 	if (datapicker) {
 		factory->container("datapicker", this)->setEnabled(true);
 		//populate datapicker-menu
-		auto view = qobject_cast<DatapickerView*>(datapicker->view());
-		auto menu = qobject_cast<QMenu*>(factory->container("datapicker", this));
+		auto* view = qobject_cast<DatapickerView*>(datapicker->view());
+		auto* menu = qobject_cast<QMenu*>(factory->container("datapicker", this));
 		menu->clear();
 		view->createContextMenu(menu);
 
 		//populate spreadsheet-toolbar
-		auto toolbar = qobject_cast<QToolBar*>(factory->container("datapicker_toolbar", this));
+		auto* toolbar = qobject_cast<QToolBar*>(factory->container("datapicker_toolbar", this));
 		toolbar->clear();
 		view->fillToolBar(toolbar);
 		toolbar->setVisible(true);
 	} else {
 		factory->container("datapicker", this)->setEnabled(false);
 		factory->container("datapicker_toolbar", this)->setVisible(false);
 	}
 }
 
 /*!
 	creates a new empty project. Returns \c true, if a new project was created.
 */
 bool MainWin::newProject() {
 	//close the current project, if available
 	if (!closeProject())
 		return false;
 
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 
 	if (m_project)
 		delete m_project;
 
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 
 	m_project = new Project();
 	m_currentAspect = m_project;
 	m_currentFolder = m_project;
 
 	KConfigGroup group = KSharedConfig::openConfig()->group( "Settings_General" );
 	Project::MdiWindowVisibility vis = Project::MdiWindowVisibility(group.readEntry("MdiWindowVisibility", 0));
 	m_project->setMdiWindowVisibility( vis );
 	if (vis == Project::folderOnly)
 		m_visibilityFolderAction->setChecked(true);
 	else if (vis == Project::folderAndSubfolders)
 		m_visibilitySubfolderAction->setChecked(true);
 	else
 		m_visibilityAllAction->setChecked(true);
 
 	m_aspectTreeModel = new AspectTreeModel(m_project, this);
 
 	//newProject is called for the first time, there is no project explorer yet
 	//-> initialize the project explorer,  the GUI-observer and the dock widgets.
 	if (m_projectExplorer == nullptr) {
 		m_projectExplorerDock = new QDockWidget(this);
 		m_projectExplorerDock->setObjectName("projectexplorer");
 		m_projectExplorerDock->setWindowTitle(i18nc("@title:window", "Project Explorer"));
 		addDockWidget(Qt::LeftDockWidgetArea, m_projectExplorerDock);
 
 		m_projectExplorer = new ProjectExplorer(m_projectExplorerDock);
 		m_projectExplorerDock->setWidget(m_projectExplorer);
 
 		connect(m_projectExplorer, SIGNAL(currentAspectChanged(AbstractAspect*)),
 		        this, SLOT(handleCurrentAspectChanged(AbstractAspect*)));
 		connect(m_projectExplorerDock, SIGNAL(visibilityChanged(bool)), SLOT(projectExplorerDockVisibilityChanged(bool)));
 
 		//Properties dock
 		m_propertiesDock = new QDockWidget(this);
 		m_propertiesDock->setObjectName("aspect_properties_dock");
 		m_propertiesDock->setWindowTitle(i18nc("@title:window", "Properties"));
 		addDockWidget(Qt::RightDockWidgetArea, m_propertiesDock);
 
-		auto sa = new QScrollArea(m_propertiesDock);
+		auto* sa = new QScrollArea(m_propertiesDock);
 		stackedWidget = new QStackedWidget(sa);
 		sa->setWidget(stackedWidget);
 		sa->setWidgetResizable(true);
 		m_propertiesDock->setWidget(sa);
 
 		connect(m_propertiesDock, SIGNAL(visibilityChanged(bool)), SLOT(propertiesDockVisibilityChanged(bool)));
 
 		//GUI-observer;
 		m_guiObserver = new GuiObserver(this);
 	}
 
 	m_projectExplorer->setModel(m_aspectTreeModel);
 	m_projectExplorer->setProject(m_project);
 	m_projectExplorer->setCurrentAspect(m_project);
 
 	m_projectExplorerDock->show();
 	m_propertiesDock->show();
 	updateGUIOnProjectChanges();
 
 	connect(m_project, SIGNAL(aspectAdded(const AbstractAspect*)), this, SLOT(handleAspectAdded(const AbstractAspect*)));
 	connect(m_project, SIGNAL(aspectRemoved(const AbstractAspect*,const AbstractAspect*,const AbstractAspect*)),
 	        this, SLOT(handleAspectRemoved(const AbstractAspect*,const AbstractAspect*,const AbstractAspect*)));
 	connect(m_project, SIGNAL(aspectAboutToBeRemoved(const AbstractAspect*)),
 	        this, SLOT(handleAspectAboutToBeRemoved(const AbstractAspect*)));
 	connect(m_project, SIGNAL(statusInfo(QString)), statusBar(), SLOT(showMessage(QString)));
 	connect(m_project, SIGNAL(changed()), this, SLOT(projectChanged()));
 	connect(m_project, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)));
 	connect(m_project, SIGNAL(requestFolderContextMenu(const Folder*,QMenu*)), this, SLOT(createFolderContextMenu(const Folder*,QMenu*)));
 	connect(m_project, SIGNAL(mdiWindowVisibilityChanged()), this, SLOT(updateMdiWindowVisibility()));
 
 	m_undoViewEmptyLabel = i18n("%1: created", m_project->name());
 	setCaption(m_project->name());
 
 	return true;
 }
 
 void MainWin::openProject() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "MainWin");
 	const QString& dir = conf.readEntry("LastOpenDir", "");
 	const QString& path = QFileDialog::getOpenFileName(this,i18n("Open Project"), dir,
 #ifdef HAVE_LIBORIGIN
 	                      i18n("LabPlot Projects (%1);;Origin Projects (%2)", Project::supportedExtensions(), OriginProjectParser::supportedExtensions()) );
 #else
 	                      i18n("LabPlot Projects (%1)", Project::supportedExtensions()) );
 #endif
 
 	if (path.isEmpty())// "Cancel" was clicked
 		return;
 
 	this->openProject(path);
 
 	//save new "last open directory"
 	int pos = path.lastIndexOf(QDir::separator());
 	if (pos != -1) {
 		const QString& newDir = path.left(pos);
 		if (newDir != dir)
 			conf.writeEntry("LastOpenDir", newDir);
 	}
 }
 
 void MainWin::openProject(const QString& filename) {
 	if (filename == m_currentFileName) {
 		KMessageBox::information(this, i18n("The project file %1 is already opened.", filename), i18n("Open Project"));
 		return;
 	}
 
 	if (!newProject())
 		return;
 
 	WAIT_CURSOR;
 	QElapsedTimer timer;
 	timer.start();
 	bool rc = false;
 	if (Project::isLabPlotProject(filename))
 		rc = m_project->load(filename);
 #ifdef HAVE_LIBORIGIN
 	else if (OriginProjectParser::isOriginProject(filename)) {
 		OriginProjectParser parser;
 		parser.setProjectFileName(filename);
 		parser.importTo(m_project, QStringList()); //TODO: add return code
 		rc = true;
 	}
 #endif
 
 	if (!rc) {
 		closeProject();
 		RESET_CURSOR;
 		return;
 	}
 
 	m_currentFileName = filename;
 	m_project->setFileName(filename);
 	m_project->undoStack()->clear();
 	m_undoViewEmptyLabel = i18n("%1: opened", m_project->name());
 	m_recentProjectsAction->addUrl( QUrl(filename) );
 	setCaption(m_project->name());
 	updateGUIOnProjectChanges();
 	updateGUI(); //there are most probably worksheets or spreadsheets in the open project -> update the GUI
 	m_saveAction->setEnabled(false);
 
 	statusBar()->showMessage( i18n("Project successfully opened (in %1 seconds).", (float)timer.elapsed()/1000) );
 
 	if (m_autoSaveActive)
 		m_autoSaveTimer.start();
 
 	RESET_CURSOR;
 }
 
 void MainWin::openRecentProject(const QUrl& url) {
 	if (url.isLocalFile())	// fix for Windows
 		this->openProject(url.toLocalFile());
 	else
 		this->openProject(url.path());
 }
 
 /*!
 	Closes the current project, if available. Return \c true, if the project was closed.
 */
 bool MainWin::closeProject() {
 	if (m_project == nullptr)
 		return true; //nothing to close
 
 	if (warnModified())
 		return false;
 
 	delete m_aspectTreeModel;
 	m_aspectTreeModel = nullptr;
 	delete m_project;
 	m_project = nullptr;
 	m_currentFileName = "";
 
 	//update the UI if we're just closing a project
 	//and not closing(quitting) the application
 	if (!m_closing) {
 		m_projectExplorerDock->hide();
 		m_propertiesDock->hide();
 		m_currentAspect = nullptr;
 		m_currentFolder = nullptr;
 		updateGUIOnProjectChanges();
 
 		if (m_autoSaveActive)
 			m_autoSaveTimer.stop();
 	}
 
 	return true;
 }
 
 bool MainWin::saveProject() {
 	const QString& fileName = m_project->fileName();
 	if (fileName.isEmpty())
 		return saveProjectAs();
 	else
 		return save(fileName);
 }
 
 bool MainWin::saveProjectAs() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "MainWin");
 	const QString& dir = conf.readEntry("LastOpenDir", "");
 	QString path  = QFileDialog::getSaveFileName(this, i18n("Save Project As"), dir,
 	                i18n("LabPlot Projects (*.lml *.lml.gz *.lml.bz2 *.lml.xz *.LML *.LML.GZ *.LML.BZ2 *.LML.XZ)"));
 
 	if (path.isEmpty())// "Cancel" was clicked
 		return false;
 
 	if (path.contains(QLatin1String(".lml"), Qt::CaseInsensitive) == false)
 		path.append(QLatin1String(".lml"));
 
 	//save new "last open directory"
 	int pos = path.lastIndexOf(QDir::separator());
 	if (pos != -1) {
 		const QString& newDir = path.left(pos);
 		if (newDir != dir)
 			conf.writeEntry("LastOpenDir", newDir);
 	}
 
 	return save(path);
 }
 
 /*!
  * auxiliary function that does the actual saving of the project
  */
 bool MainWin::save(const QString& fileName) {
 	WAIT_CURSOR;
 	// use file ending to find out how to compress file
 	QIODevice* file;
 	// if ending is .lml, do gzip compression anyway
 	if (fileName.endsWith(QLatin1String(".lml")))
 		file = new KCompressionDevice(fileName, KCompressionDevice::GZip);
 	else
 		file = new KFilterDev(fileName);
 
 	if (file == nullptr)
 		file = new QFile(fileName);
 
 	bool ok;
 	if (file->open(QIODevice::WriteOnly)) {
 		m_project->setFileName(fileName);
 
 		QXmlStreamWriter writer(file);
 		m_project->save(&writer);
 		m_project->undoStack()->clear();
 		m_project->setChanged(false);
 		file->close();
 
 		setCaption(m_project->name());
 		statusBar()->showMessage(i18n("Project saved"));
 		m_saveAction->setEnabled(false);
 		m_recentProjectsAction->addUrl( QUrl(fileName) );
 		ok = true;
 
 		//if the project dock is visible, refresh the shown content
 		//(version and modification time might have been changed)
 		if (stackedWidget->currentWidget() == projectDock)
 			projectDock->setProject(m_project);
 
 		//we have a file name now
 		// -> auto save can be activated now if not happened yet
 		if (m_autoSaveActive && !m_autoSaveTimer.isActive())
 			m_autoSaveTimer.start();
 	} else {
 		KMessageBox::error(this, i18n("Sorry. Could not open file for writing."));
 		ok = false;
 	}
 
 	delete file;
 
 	RESET_CURSOR;
 	return ok;
 }
 
 /*!
  * automatically saves the project in the specified time interval.
  */
 void MainWin::autoSaveProject() {
 	//don't auto save when there are no changes or the file name
 	//was not provided yet (the project was never explicitly saved yet).
 	if ( !m_project->hasChanged() || m_project->fileName().isEmpty())
 		return;
 
 	this->saveProject();
 }
 
 /*!
 	prints the current sheet (worksheet, spreadsheet or matrix)
 */
 void MainWin::print() {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	statusBar()->showMessage(i18n("Preparing printing of %1", part->name()));
 	if (part->printView())
 		statusBar()->showMessage(i18n("%1 printed", part->name()));
 	else
 		statusBar()->showMessage("");
 }
 
 void MainWin::printPreview() {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	statusBar()->showMessage(i18n("Preparing printing of %1", part->name()));
 	if (part->printPreview())
 		statusBar()->showMessage(i18n("%1 printed", part->name()));
 	else
 		statusBar()->showMessage("");
 }
 
 /**************************************************************************************/
 
 /*!
 	adds a new Folder to the project.
 */
 void MainWin::newFolder() {
 	Folder* folder = new Folder(i18n("Folder"));
 	this->addAspectToProject(folder);
 }
 
 /*!
 	adds a new Workbook to the project.
 */
 void MainWin::newWorkbook() {
 	Workbook* workbook = new Workbook(i18n("Workbook"));
 	this->addAspectToProject(workbook);
 }
 
 /*!
 	adds a new Datapicker to the project.
 */
 void MainWin::newDatapicker() {
 	Datapicker* datapicker = new Datapicker(i18n("Datapicker"));
 	this->addAspectToProject(datapicker);
 }
 /*!
 	adds a new Spreadsheet to the project.
 */
 void MainWin::newSpreadsheet() {
 	Spreadsheet* spreadsheet = new Spreadsheet(i18n("Spreadsheet"));
 
 	//if the current active window is a workbook and no folder/project is selected in the project explorer,
 	//add the new spreadsheet to the workbook
 	Workbook* workbook = activeWorkbook();
 	if (workbook) {
 		QModelIndex index = m_projectExplorer->currentIndex();
-		const auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+		const auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		if (!aspect->inherits("Folder")) {
 			workbook->addChild(spreadsheet);
 			return;
 		}
 	}
 
 	this->addAspectToProject(spreadsheet);
 }
 
 /*!
 	adds a new Matrix to the project.
 */
 void MainWin::newMatrix() {
 	Matrix* matrix = new Matrix(i18n("Matrix"));
 
 	//if the current active window is a workbook and no folder/project is selected in the project explorer,
 	//add the new matrix to the workbook
 	Workbook* workbook = activeWorkbook();
 	if (workbook) {
 		QModelIndex index = m_projectExplorer->currentIndex();
-		const auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+		const auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 		if (!aspect->inherits("Folder")) {
 			workbook->addChild(matrix);
 			return;
 		}
 	}
 
 	this->addAspectToProject(matrix);
 }
 
 /*!
 	adds a new Worksheet to the project.
 */
 void MainWin::newWorksheet() {
 	Worksheet* worksheet = new Worksheet(i18n("Worksheet"));
 	this->addAspectToProject(worksheet);
 }
 
 /*!
 	adds a new Note to the project.
 */
 void MainWin::newNotes() {
 	Note* notes = new Note(i18n("Note"));
 	this->addAspectToProject(notes);
 }
 
 /*!
 	returns a pointer to a Workbook-object, if the currently active Mdi-Subwindow is \a WorkbookView.
 	Otherwise returns \a 0.
 */
 Workbook* MainWin::activeWorkbook() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	return dynamic_cast<Workbook*>(part);
 }
 
 /*!
 	returns a pointer to a Datapicker-object, if the currently active Mdi-Subwindow is \a DatapickerView.
 	Otherwise returns \a 0.
 */
 Datapicker* MainWin::activeDatapicker() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	return dynamic_cast<Datapicker*>(part);
 }
 
 /*!
 	returns a pointer to a \c Spreadsheet object, if the currently active Mdi-Subwindow
 	or if the currently selected tab in a \c WorkbookView is a \c SpreadsheetView
 	Otherwise returns \c 0.
 */
 Spreadsheet* MainWin::activeSpreadsheet() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	Spreadsheet* spreadsheet = nullptr;
-	const auto workbook = dynamic_cast<const Workbook*>(part);
+	const auto* workbook = dynamic_cast<const Workbook*>(part);
 	if (workbook) {
 		spreadsheet = workbook->currentSpreadsheet();
 		if (!spreadsheet) {
 			//potentially, the spreadsheet was not selected in workbook yet since the selection in project explorer
 			//arrives in workbook's slot later than in this function
 			//->check whether we have a spreadsheet or one of its columns currently selected in the project explorer
 			spreadsheet = dynamic_cast<Spreadsheet*>(m_currentAspect);
 			if (!spreadsheet) {
 				if (m_currentAspect->parentAspect())
 					spreadsheet = dynamic_cast<Spreadsheet*>(m_currentAspect->parentAspect());
 			}
 		}
 	} else
 		spreadsheet = dynamic_cast<Spreadsheet*>(part);
 
 	return spreadsheet;
 }
 
 /*!
 	returns a pointer to a \c Matrix object, if the currently active Mdi-Subwindow
 	or if the currently selected tab in a \c WorkbookView is a \c MatrixView
 	Otherwise returns \c 0.
 */
 Matrix* MainWin::activeMatrix() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	Matrix* matrix = nullptr;
-	auto workbook = dynamic_cast<Workbook*>(part);
+	const auto* workbook = dynamic_cast<Workbook*>(part);
 	if (workbook) {
 		matrix = workbook->currentMatrix();
 		if (!matrix) {
 			//potentially, the matrix was not selected in workbook yet since the selection in project explorer
 			//arrives in workbook's slot later than in this function
 			//->check whether we have a matrix currently selected in the project explorer
 			matrix = dynamic_cast<Matrix*>(m_currentAspect);
 		}
 	} else
 		matrix = dynamic_cast<Matrix*>(part);
 
 	return matrix;
 }
 
 /*!
 	returns a pointer to a Worksheet-object, if the currently active Mdi-Subwindow is \a WorksheetView
 	Otherwise returns \a 0.
 */
 Worksheet* MainWin::activeWorksheet() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	return dynamic_cast<Worksheet*>(part);
 }
 
 #ifdef HAVE_CANTOR_LIBS
 /*
     adds a new Cantor Spreadsheet to the project.
 */
 void MainWin::newCantorWorksheet(QAction* action) {
 	CantorWorksheet* cantorworksheet = new CantorWorksheet(action->data().toString());
 	this->addAspectToProject(cantorworksheet);
 }
 
 /********************************************************************************/
 /*!
     returns a pointer to a CantorWorksheet-object, if the currently active Mdi-Subwindow is \a CantorWorksheetView
     Otherwise returns \a 0.
 */
 CantorWorksheet* MainWin::activeCantorWorksheet() const {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return nullptr;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	Q_ASSERT(part);
 	return dynamic_cast<CantorWorksheet*>(part);
 }
 #endif
 
 /*!
 	called if there were changes in the project.
 	Adds "changed" to the window caption and activates the save-Action.
 */
 void MainWin::projectChanged() {
 	setCaption(i18n("%1    [Changed]", m_project->name()));
 	m_saveAction->setEnabled(true);
 	m_undoAction->setEnabled(true);
 	return;
 }
 
 void MainWin::handleCurrentSubWindowChanged(QMdiSubWindow* win) {
 	if (!win)
 		return;
 
-	auto view = qobject_cast<PartMdiView*>(win);
+	auto* view = qobject_cast<PartMdiView*>(win);
 	if (!view) {
 		updateGUI();
 		return;
 	}
 
 	if (view == m_currentSubWindow) {
 		//do nothing, if the current sub-window gets selected again.
 		//This event happens, when labplot loses the focus (modal window is opened or the user switches to another application)
 		//and gets it back (modal window is closed or the user switches back to labplot).
 		return;
 	} else
 		m_currentSubWindow = view;
 
 	updateGUI();
 	if (!m_suppressCurrentSubWindowChangedEvent)
 		m_projectExplorer->setCurrentAspect(view->part());
 }
 
 void MainWin::handleAspectAdded(const AbstractAspect* aspect) {
-	const auto part = dynamic_cast<const AbstractPart*>(aspect);
+	const auto* part = dynamic_cast<const AbstractPart*>(aspect);
 	if (part) {
 // 		connect(part, &AbstractPart::importFromFileRequested, this, &MainWin::importFileDialog);
 		connect(part, SIGNAL(importFromFileRequested()), this, SLOT(importFileDialog()));
 		connect(part, &AbstractPart::importFromSQLDatabaseRequested, this, &MainWin::importSqlDialog);
 		//TODO: export, print and print preview should be handled in the views and not in MainWin.
 		connect(part, SIGNAL(exportRequested()), this, SLOT(exportDialog()));
 		connect(part, SIGNAL(printRequested()), this, SLOT(print()));
 		connect(part, SIGNAL(printPreviewRequested()), this, SLOT(printPreview()));
 		connect(part, SIGNAL(showRequested()), this, SLOT(handleShowSubWindowRequested()));
 	}
 }
 
 void MainWin::handleAspectRemoved(const AbstractAspect* parent,const AbstractAspect* before,const AbstractAspect* aspect) {
 	Q_UNUSED(before);
 	Q_UNUSED(aspect);
 	m_projectExplorer->setCurrentAspect(parent);
 }
 
 void MainWin::handleAspectAboutToBeRemoved(const AbstractAspect *aspect) {
-	const auto part = qobject_cast<const AbstractPart*>(aspect);
+	const auto* part = qobject_cast<const AbstractPart*>(aspect);
 	if (!part) return;
 
-	const auto workbook = dynamic_cast<const Workbook*>(aspect->parentAspect());
-	auto datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect());
+	const auto* workbook = dynamic_cast<const Workbook*>(aspect->parentAspect());
+	auto* datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect());
 	if (!datapicker)
 		datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect()->parentAspect());
 
 	if (!workbook && !datapicker) {
 		PartMdiView* win = part->mdiSubWindow();
 		if (win)
 			m_mdiArea->removeSubWindow(win);
 	}
 }
 
 /*!
     called when the current aspect in the tree of the project explorer was changed.
     Selects the new aspect.
 */
 void MainWin::handleCurrentAspectChanged(AbstractAspect *aspect) {
 	if (!aspect)
 		aspect = m_project; // should never happen, just in case
 
 	m_suppressCurrentSubWindowChangedEvent = true;
 	if (aspect->folder() != m_currentFolder) {
 		m_currentFolder = aspect->folder();
 		updateMdiWindowVisibility();
 	}
 
 	m_currentAspect = aspect;
 
 	//activate the corresponding MDI sub window for the current aspect
 	activateSubWindowForAspect(aspect);
 	m_suppressCurrentSubWindowChangedEvent = false;
 
 	updateGUI();
 }
 
 void MainWin::activateSubWindowForAspect(const AbstractAspect* aspect) const {
-	const auto part = dynamic_cast<const AbstractPart*>(aspect);
+	const auto* part = dynamic_cast<const AbstractPart*>(aspect);
 	if (part) {
 		//for LiveDataSource we currently don't show any view
 		/*if (dynamic_cast<const LiveDataSource*>(part))
 		    return;*/
 
 		PartMdiView* win;
 
 		//for aspects being children of a Workbook, we show workbook's window, otherwise the window of the selected part
-		const auto workbook = dynamic_cast<const Workbook*>(aspect->parentAspect());
-		auto datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect());
+		const auto* workbook = dynamic_cast<const Workbook*>(aspect->parentAspect());
+		auto* datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect());
 		if (!datapicker)
 			datapicker = dynamic_cast<const Datapicker*>(aspect->parentAspect()->parentAspect());
 
 		if (workbook)
 			win = workbook->mdiSubWindow();
 		else if (datapicker)
 			win = datapicker->mdiSubWindow();
 		else
 			win = part->mdiSubWindow();
 
 		if (m_mdiArea->subWindowList().indexOf(win) == -1) {
 			if (dynamic_cast<const Note*>(part))
 				m_mdiArea->addSubWindow(win, Qt::Tool);
 			else
 				m_mdiArea->addSubWindow(win);
 			win->show();
 
 			//Qt provides its own "system menu" for every sub-window. The shortcut for the close-action
 			//in this menu collides with our global m_closeAction.
 			//remove the shortcuts in the system menu to avoid this collision.
 			QMenu* menu = win->systemMenu();
 			if (menu) {
 				for (QAction* action : menu->actions())
 					action->setShortcut(QKeySequence());
 			}
 		}
 		m_mdiArea->setActiveSubWindow(win);
 	} else {
 		//activate the mdiView of the parent, if a child was selected
 		const AbstractAspect* parent = aspect->parentAspect();
 		if (parent) {
 			activateSubWindowForAspect(parent);
 
 			//if the parent's parent is a Workbook (a column of a spreadsheet in workbook was selected),
 			//we need to select the corresponding tab in WorkbookView too
 			if (parent->parentAspect()) {
-				auto workbook = dynamic_cast<Workbook*>(parent->parentAspect());
-				auto datapicker = dynamic_cast<Datapicker*>(parent->parentAspect());
+				auto* workbook = dynamic_cast<Workbook*>(parent->parentAspect());
+				auto* datapicker = dynamic_cast<Datapicker*>(parent->parentAspect());
 				if (!datapicker)
 					datapicker = dynamic_cast<Datapicker*>(parent->parentAspect()->parentAspect());
 
 				if (workbook)
 					workbook->childSelected(parent);
 				else if (datapicker)
 					datapicker->childSelected(parent);
 			}
 		}
 	}
 	return;
 }
 
 void MainWin::setMdiWindowVisibility(QAction * action) {
 	m_project->setMdiWindowVisibility((Project::MdiWindowVisibility)(action->data().toInt()));
 }
 
 /*!
 	shows the sub window of a worksheet, matrix or a spreadsheet.
 	Used if the window was closed before and the user asks to show
 	the window again via the context menu in the project explorer.
 */
 void MainWin::handleShowSubWindowRequested() {
 	activateSubWindowForAspect(m_currentAspect);
 }
 
 /*!
 	this is called on a right click on the root folder in the project explorer
 */
 void MainWin::createContextMenu(QMenu* menu) const {
 	menu->addMenu(m_newMenu);
 
 	//The tabbed view collides with the visibility policy for the subwindows.
 	//Hide the menus for the visibility policy if the tabbed view is used.
 	if (m_mdiArea->viewMode() != QMdiArea::TabbedView)
 		menu->addMenu(m_visibilityMenu);
 }
 
 /*!
 	this is called on a right click on a non-root folder in the project explorer
 */
 void MainWin::createFolderContextMenu(const Folder* folder, QMenu* menu) const {
 	Q_UNUSED(folder);
 
 	//Folder provides it's own context menu. Add a separator before adding additional actions.
 	menu->addSeparator();
 	this->createContextMenu(menu);
 }
 
 void MainWin::undo() {
 	WAIT_CURSOR;
 	m_project->undoStack()->undo();
 	if (m_project->undoStack()->index()==0) {
 		setCaption(m_project->name());
 		m_saveAction->setEnabled(false);
 		m_undoAction->setEnabled(false);
 		m_project->setChanged(false);
 	}
 	m_redoAction->setEnabled(true);
 	RESET_CURSOR;
 }
 
 void MainWin::redo() {
 	WAIT_CURSOR;
 	m_project->undoStack()->redo();
 	projectChanged();
 	if (m_project->undoStack()->index() == m_project->undoStack()->count())
 		m_redoAction->setEnabled(false);
 	RESET_CURSOR;
 }
 
 /*!
 	Shows/hides mdi sub-windows depending on the current visibility policy.
 */
 void MainWin::updateMdiWindowVisibility() const {
 	QList<QMdiSubWindow *> windows = m_mdiArea->subWindowList();
 	PartMdiView* part_view;
 	switch (m_project->mdiWindowVisibility()) {
 	case Project::allMdiWindows:
 		for (auto* window : windows)
 			window->show();
 
 		break;
 	case Project::folderOnly:
 		for (auto* window : windows) {
 			part_view = qobject_cast<PartMdiView *>(window);
 			Q_ASSERT(part_view);
 			if (part_view->part()->folder() == m_currentFolder)
 				part_view->show();
 			else
 				part_view->hide();
 		}
 		break;
 	case Project::folderAndSubfolders:
 		for (auto* window : windows) {
 			part_view = qobject_cast<PartMdiView *>(window);
 			if (part_view->part()->isDescendantOf(m_currentFolder))
 				part_view->show();
 			else
 				part_view->hide();
 		}
 		break;
 	}
 }
 
 void MainWin::toggleDockWidget(QAction* action)  {
 	if (action->objectName() == "toggle_project_explorer_dock") {
 		if (m_projectExplorerDock->isVisible())
 			toggleHideWidget(m_projectExplorerDock, true);
 		else
 			toggleShowWidget(m_projectExplorerDock, true);
 	} else if (action->objectName() == "toggle_properties_explorer_dock") {
 		if (m_propertiesDock->isVisible())
 			toggleHideWidget(m_propertiesDock, false);
 		else
 			toggleShowWidget(m_propertiesDock, false);
 	}
 }
 
 void MainWin::toggleHideWidget(QWidget* widget, bool hideToLeft)
 {
-	auto timeline = new QTimeLine(800, this);
+	auto* timeline = new QTimeLine(800, this);
 	timeline->setEasingCurve(QEasingCurve::InOutQuad);
 
 	connect(timeline, &QTimeLine::valueChanged, [=] {
 		const qreal value = timeline->currentValue();
 		const int widgetWidth = widget->width();
 		const int widgetPosY = widget->pos().y();
 
 		int moveX = 0;
 		if (hideToLeft) {
 			moveX = static_cast<int>(value * widgetWidth) - widgetWidth;
 		}
 		else {
 			const int frameRight = this->frameGeometry().right();
 			moveX = frameRight - static_cast<int>(value * widgetWidth);
 		}
 		widget->move(moveX, widgetPosY);
 	});
 	timeline->setDirection(QTimeLine::Backward);
 	timeline->start();
 
 	connect(timeline, &QTimeLine::finished, [widget] {widget->hide();});
 	connect(timeline, &QTimeLine::finished, timeline, &QTimeLine::deleteLater);
 }
 
 void MainWin::toggleShowWidget(QWidget* widget, bool showToRight)
 {
-	auto timeline = new QTimeLine(800, this);
+	auto* timeline = new QTimeLine(800, this);
 	timeline->setEasingCurve(QEasingCurve::InOutQuad);
 
 	connect(timeline, &QTimeLine::valueChanged, [=]() {
 		if (widget->isHidden()) {
 			widget->show();
 		}
 		const qreal value = timeline->currentValue();
 		const int widgetWidth = widget->width();
 		const int widgetPosY = widget->pos().y();
 		int moveX = 0;
 
 		if (showToRight) {
 			moveX = static_cast<int>(value * widgetWidth) - widgetWidth;
 		}
 		else {
 			const int frameRight = this->frameGeometry().right();
 			moveX = frameRight - static_cast<int>(value * widgetWidth);
 		}
 		widget->move(moveX, widgetPosY);
 	});
 
 	timeline->setDirection(QTimeLine::Forward);
 	timeline->start();
 
 	connect(timeline, &QTimeLine::finished, timeline, &QTimeLine::deleteLater);
 }
 
 void MainWin::projectExplorerDockVisibilityChanged(bool visible) {
 	m_toggleProjectExplorerDockAction->setChecked(visible);
 }
 
 void MainWin::propertiesDockVisibilityChanged(bool visible) {
 	m_togglePropertiesDockAction->setChecked(visible);
 }
 
 void MainWin::toggleFullScreen() {
 	if (this->windowState() == Qt::WindowFullScreen)
 		this->setWindowState(m_lastWindowState);
 	else {
 		m_lastWindowState = this->windowState();
 		this->showFullScreen();
 	}
 }
 
 void MainWin::closeEvent(QCloseEvent* event) {
 	m_closing = true;
 	if (!this->closeProject()) {
 		m_closing = false;
 		event->ignore();
 	}
 }
 
 void MainWin::dragEnterEvent(QDragEnterEvent* event) {
 	event->accept();
 }
 
 void MainWin::dropEvent(QDropEvent* event) {
 	if (event->mimeData() && !event->mimeData()->urls().isEmpty()) {
 		QUrl url = event->mimeData()->urls().at(0);
 		const QString& f = url.toLocalFile();
 
 #ifdef HAVE_LIBORIGIN
 		if (Project::isLabPlotProject(f) || OriginProjectParser::isOriginProject(f))
 #else
 		if (Project::isLabPlotProject(f))
 #endif
 				openProject(f);
 		else {
 			if (!m_project)
 				newProject();
 			importFileDialog(f);
 		}
 
 		event->accept();
 	} else
 		event->ignore();
 }
 
 void MainWin::handleSettingsChanges() {
 	const KConfigGroup group = KSharedConfig::openConfig()->group( "Settings_General" );
 
 	QMdiArea::ViewMode viewMode = QMdiArea::ViewMode(group.readEntry("ViewMode", 0));
 	if (m_mdiArea->viewMode() != viewMode) {
 		m_mdiArea->setViewMode(viewMode);
 		if (viewMode == QMdiArea::SubWindowView)
 			this->updateMdiWindowVisibility();
 	}
 
 	if (m_mdiArea->viewMode() == QMdiArea::TabbedView) {
 		m_tileWindows->setVisible(false);
 		m_cascadeWindows->setVisible(false);
 		QTabWidget::TabPosition tabPosition = QTabWidget::TabPosition(group.readEntry("TabPosition", 0));
 		if (m_mdiArea->tabPosition() != tabPosition)
 			m_mdiArea->setTabPosition(tabPosition);
 	} else {
 		m_tileWindows->setVisible(true);
 		m_cascadeWindows->setVisible(true);
 	}
 
 	//autosave
 	bool autoSave = group.readEntry("AutoSave", 0);
 	if (m_autoSaveActive != autoSave) {
 		m_autoSaveActive = autoSave;
 		if (autoSave)
 			m_autoSaveTimer.start();
 		else
 			m_autoSaveTimer.stop();
 	}
 
 	int interval = group.readEntry("AutoSaveInterval", 1);
 	interval *= 60*1000;
 	if (interval != m_autoSaveTimer.interval())
 		m_autoSaveTimer.setInterval(interval);
 }
 
 /***************************************************************************************/
 /************************************** dialogs ***************************************/
 /***************************************************************************************/
 /*!
   shows the dialog with the Undo-history.
 */
 void MainWin::historyDialog() {
 	if (!m_project->undoStack())
 		return;
 
-	auto dialog = new HistoryDialog(this, m_project->undoStack(), m_undoViewEmptyLabel);
+	auto* dialog = new HistoryDialog(this, m_project->undoStack(), m_undoViewEmptyLabel);
 	int index = m_project->undoStack()->index();
 	if (dialog->exec() != QDialog::Accepted) {
 		if (m_project->undoStack()->count() != 0)
 			m_project->undoStack()->setIndex(index);
 	}
 
 	//disable undo/redo-actions if the history was cleared
 	//(in both cases, when accepted or rejected in the dialog)
 	if (m_project->undoStack()->count() == 0) {
 		m_undoAction->setEnabled(false);
 		m_redoAction->setEnabled(false);
 	}
 }
 
 /*!
   Opens the dialog to import data to the selected workbook, spreadsheet or matrix
 */
 void MainWin::importFileDialog(const QString& fileName) {
 	DEBUG("MainWin::importFileDialog()");
-	auto dlg = new ImportFileDialog(this, false, fileName);
+	auto* dlg = new ImportFileDialog(this, false, fileName);
 
 	// select existing container
 	if (m_currentAspect->inherits("Spreadsheet") || m_currentAspect->inherits("Matrix") || m_currentAspect->inherits("Workbook"))
 		dlg->setCurrentIndex( m_projectExplorer->currentIndex());
 	else if (m_currentAspect->inherits("Column")) {
 		if (m_currentAspect->parentAspect()->inherits("Spreadsheet"))
 			dlg->setCurrentIndex(m_aspectTreeModel->modelIndexOfAspect(m_currentAspect->parentAspect()));
 	}
 
 	if (dlg->exec() == QDialog::Accepted) {
 		dlg->importTo(statusBar());
 		m_project->setChanged(true);
 	}
 
 	delete dlg;
 	DEBUG("MainWin::importFileDialog() DONE");
 }
 
 void MainWin::importSqlDialog() {
 	DEBUG("MainWin::importSqlDialog()");
-	auto dlg = new ImportSQLDatabaseDialog(this);
+	auto* dlg = new ImportSQLDatabaseDialog(this);
 
 	// select existing container
 	if (m_currentAspect->inherits("Spreadsheet") || m_currentAspect->inherits("Matrix") || m_currentAspect->inherits("Workbook"))
 		dlg->setCurrentIndex( m_projectExplorer->currentIndex());
 	else if (m_currentAspect->inherits("Column")) {
 		if (m_currentAspect->parentAspect()->inherits("Spreadsheet"))
 			dlg->setCurrentIndex( m_aspectTreeModel->modelIndexOfAspect(m_currentAspect->parentAspect()));
 	}
 
 	if (dlg->exec() == QDialog::Accepted) {
 		dlg->importTo(statusBar());
 		m_project->setChanged(true);
 	}
 
 	delete dlg;
 	DEBUG("MainWin::importSqlDialog() DONE");
 }
 
 void MainWin::importProjectDialog() {
 	DEBUG("MainWin::importProjectDialog()");
 
 	ImportProjectDialog::ProjectType type;
 	if (QObject::sender() == m_importOpjAction)
 		type = ImportProjectDialog::ProjectOrigin;
 	else
 		type = ImportProjectDialog::ProjectLabPlot;
 
-	auto dlg = new ImportProjectDialog(this, type);
+	auto* dlg = new ImportProjectDialog(this, type);
 
 	// set current folder
 	dlg->setCurrentFolder(m_currentFolder);
 
 	if (dlg->exec() == QDialog::Accepted) {
 		dlg->importTo(statusBar());
 		m_project->setChanged(true);
 	}
 
 	delete dlg;
 
 	DEBUG("MainWin::importProjectDialog() DONE");
 }
 
 /*!
   opens the dialog for the export of the currently active worksheet, spreadsheet or matrix.
  */
 void MainWin::exportDialog() {
 	QMdiSubWindow* win = m_mdiArea->currentSubWindow();
 	if (!win)
 		return;
 
 	AbstractPart* part = dynamic_cast<PartMdiView*>(win)->part();
 	if (part->exportView())
 		statusBar()->showMessage(i18n("%1 exported", part->name()));
 }
 
 void MainWin::editFitsFileDialog() {
-	auto editDialog = new FITSHeaderEditDialog(this);
+	auto* editDialog = new FITSHeaderEditDialog(this);
 	if (editDialog->exec() == QDialog::Accepted) {
 		if (editDialog->saved())
 			statusBar()->showMessage(i18n("FITS files saved"));
 	}
 }
 
 /*!
   adds a new file data source to the current project.
 */
 void MainWin::newLiveDataSourceActionTriggered() {
 	ImportFileDialog* dlg = new ImportFileDialog(this, true);
 	if (dlg->exec() == QDialog::Accepted) {
 		if(static_cast<LiveDataSource::SourceType>(dlg->sourceType()) == LiveDataSource::MQTT) {
 #ifdef HAVE_MQTT
 			MQTTClient* mqttClient = new MQTTClient(i18n("MQTT Client%1", 1));
 			dlg->importToMQTT(mqttClient);
 
 			mqttClient->setName(mqttClient->clientHostName());
 			QVector<const MQTTClient*> existingClients = m_project->children<const MQTTClient>(AbstractAspect::Recursive);
 
 			//doesn't make sense to have more MQTTClients connected to the same broker
 			bool found = false;
 			for(int i = 0; i < existingClients.size(); ++i) {
 				if(existingClients[i]->clientHostName() == mqttClient->clientHostName()) {
 					found = true;
 					break;
 				}
 			}
 
 			if(!found)
 				this->addAspectToProject(mqttClient);
 			else {
 				delete mqttClient;
 				QMessageBox::warning(this, "Warning", "There already is a MQTTClient with this host name!");
 			}
 #endif
 		}
 		else {
 			LiveDataSource* dataSource = new LiveDataSource(i18n("Live data source%1", 1), false);
 			dlg->importToLiveDataSource(dataSource, statusBar());
 			this->addAspectToProject(dataSource);
 		}
 	}
 	delete dlg;
 }
 
 void MainWin::addAspectToProject(AbstractAspect* aspect) {
 	const QModelIndex& index = m_projectExplorer->currentIndex();
 	if (index.isValid()) {
-		auto parent = static_cast<AbstractAspect*>(index.internalPointer());
+		auto* parent = static_cast<AbstractAspect*>(index.internalPointer());
 #ifdef HAVE_MQTT
 		//doesn't make sense to add a new MQTTClient to an existing MQTTClient or to any of its successors
 		QString className = parent->metaObject()->className();
 		MQTTClient* clientAncestor = parent->ancestor<MQTTClient>();
 		if(className == "MQTTClient")
 			parent = parent->parentAspect();
 		else if (clientAncestor != nullptr)
 			parent = clientAncestor->parentAspect();
 #endif
 		parent->folder()->addChild(aspect);
 	} else
 		m_project->addChild(aspect);
 }
 
 void MainWin::settingsDialog() {
-	auto dlg = new SettingsDialog(this);
+	auto* dlg = new SettingsDialog(this);
 	connect (dlg, SIGNAL(settingsChanged()), this, SLOT(handleSettingsChanges()));
 	dlg->exec();
 }
diff --git a/src/kdefrontend/TemplateHandler.cpp b/src/kdefrontend/TemplateHandler.cpp
index eae91f3aa..d4a3d3d1a 100644
--- a/src/kdefrontend/TemplateHandler.cpp
+++ b/src/kdefrontend/TemplateHandler.cpp
@@ -1,220 +1,220 @@
 /***************************************************************************
     File                 : TemplateHandler.cpp
     Project              : LabPlot
     Description          : Widget for handling saving and loading of templates
     --------------------------------------------------------------------
 	Copyright            : (C) 2012 by Stefan Gerlach (stefan.gerlach@uni.kn)
 	Copyright            : (C) 2012-2016 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "TemplateHandler.h"
 
 #include <QFileInfo>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QSpacerItem>
 #include <QToolButton>
 #include <QWidgetAction>
 
 #include <KConfig>
 #include <KIconLoader>
 #include <KLocalizedString>
 
  /*!
   \class TemplateHandler
   \brief Provides a widget with buttons for saving and loading of templates.
 
   Emits \c loadConfig() and \c saveConfig() signals that have to be connected
   to the appropriate slots in the ui (mostly in the dock widgets)
 
   \ingroup kdefrontend
 */
 
 TemplateHandler::TemplateHandler(QWidget *parent, ClassName name): QWidget(parent){
-	auto horizontalLayout = new QHBoxLayout(this);
+	auto* horizontalLayout = new QHBoxLayout(this);
 	horizontalLayout->setSpacing(0);
 	horizontalLayout->setMargin(0);
 
-	auto horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+	auto* horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
 	horizontalLayout->addItem(horizontalSpacer);
 
 	int size = KIconLoader::global()->currentSize(KIconLoader::MainToolbar);
 
     m_tbLoad = new QToolButton(this);
     m_tbLoad->setIconSize(QSize(size, size));
     horizontalLayout->addWidget(m_tbLoad);
 
     m_tbSave = new QToolButton(this);
     m_tbSave->setIconSize(QSize(size, size));
     horizontalLayout->addWidget(m_tbSave);
 
     m_tbSaveDefault = new QToolButton(this);
     m_tbSaveDefault->setIconSize(QSize(size, size));
     horizontalLayout->addWidget(m_tbSaveDefault);
 
 // 	QSpacerItem* horizontalSpacer2 = new QSpacerItem(10, 20, QSizePolicy::Fixed, QSizePolicy::Minimum);
 // 	horizontalLayout->addItem(horizontalSpacer2);
 
     m_tbCopy = new QToolButton(this);
     m_tbCopy->setIconSize(QSize(size, size));
     m_tbCopy->setEnabled(false);
     horizontalLayout->addWidget(m_tbCopy);
 
     m_tbPaste = new QToolButton(this);
     m_tbPaste->setIconSize(QSize(size, size));
     m_tbPaste->setEnabled(false);
     horizontalLayout->addWidget(m_tbPaste);
 
     m_tbLoad->setIcon(QIcon::fromTheme("document-open"));
     m_tbSave->setIcon(QIcon::fromTheme("document-save"));
     m_tbSaveDefault->setIcon(QIcon::fromTheme("document-save-as"));
     m_tbCopy->setIcon(QIcon::fromTheme("edit-copy"));
     m_tbPaste->setIcon(QIcon::fromTheme("edit-paste"));
 
     connect( m_tbLoad, SIGNAL(clicked()), this, SLOT(loadMenu()));
     connect( m_tbSave, SIGNAL(clicked()), this, SLOT(saveMenu()));
     connect( m_tbSaveDefault, SIGNAL(clicked()), this, SLOT(saveDefaults()));
 
     m_className = name;
 
 	//synchronize this with the ordering in TemplateHandler::ClassName
     m_dirNames <<"spreadsheet"<<"matrix"<<"worksheet"<<"cartesianplot"<<"cartesianplotlegend"<<"xycurve"<<"axis"<<"custompoint"<<"histogram";
 
 	this->retranslateUi();
 
 	//disable the load-button if no templates are available yet
     QStringList list = QStandardPaths::locateAll(QStandardPaths::ApplicationsLocation, "templates/" + m_dirNames.at(m_className) + "/*");
     m_tbLoad->setEnabled(list.size());
 
 	//TODO: implement copy&paste of properties and activate copy- and paste-buttons again
     m_tbCopy->hide();
     m_tbPaste->hide();
 }
 
 void TemplateHandler::retranslateUi(){
     m_tbLoad->setToolTip(i18n("Load properties from a template"));
     m_tbSave->setToolTip(i18n("Save current properties as a template"));
     m_tbSaveDefault->setToolTip(i18n("Save current properties as default"));
     m_tbCopy->setToolTip(i18n("Copy properties"));
     m_tbPaste->setToolTip(i18n("Paste properties"));
 }
 
 //##############################################################################
 //##################################  Slots ####################################
 //##############################################################################
 void TemplateHandler::loadMenu() {
 	QMenu menu;
 	menu.addSection(i18n("Load From"));
 
     QStringList list = QStandardPaths::locateAll(QStandardPaths::ApplicationsLocation, "templates/" + m_dirNames.at(m_className) + "/*");
 	for (int i = 0; i < list.size(); ++i) {
 			QFileInfo fileinfo(list.at(i));
 			QAction* action = menu.addAction(fileinfo.fileName());
 			action->setData(QVariant(list.at(i)));
 	}
 	connect(&menu, SIGNAL(triggered(QAction*)), this, SLOT(loadMenuSelected(QAction*)));
 
     QPoint pos(-menu.sizeHint().width()+m_tbLoad->width(),-menu.sizeHint().height());
     menu.exec(m_tbLoad->mapToGlobal(pos));
 }
 
 void TemplateHandler::loadMenuSelected(QAction* action) {
 	KConfig config(action->data().toString(), KConfig::SimpleConfig);
 	emit loadConfigRequested(config);
 
 	emit info( i18n("Template \"%1\" was loaded.", action->text().remove('&')) );
 }
 
 void TemplateHandler::saveMenu() {
 	QMenu menu;
 	menu.addSection(i18n("Save As"));
 
     QStringList list = QStandardPaths::locateAll(QStandardPaths::ApplicationsLocation, "templates/"+ m_dirNames.at(m_className) + "/*");
 	for (int i = 0; i < list.size(); ++i) {
 			QFileInfo fileinfo(list.at(i));
 			QAction* action = menu.addAction(fileinfo.fileName());
 			menu.addAction(action);
 			action->setShortcut(QKeySequence());
 	}
 	connect(&menu, SIGNAL(triggered(QAction*)), this, SLOT(saveMenuSelected(QAction*)));
 
 	// add editable action
-	auto widgetAction = new QWidgetAction(this);
-	QFrame* frame = new QFrame(this);
-	auto layout = new QHBoxLayout(frame);
+	auto* widgetAction = new QWidgetAction(this);
+	auto* frame = new QFrame(this);
+	auto* layout = new QHBoxLayout(frame);
 
 	QLabel* label = new QLabel(i18n("New:"), frame);
 	layout->addWidget(label);
 
 	QLineEdit* leFilename = new QLineEdit("", frame);
 	layout->addWidget(leFilename);
 	connect(leFilename, SIGNAL(returnPressed(QString)), this, SLOT(saveNewSelected(QString)));
 	connect(leFilename, SIGNAL(returnPressed(QString)), &menu, SLOT(close()));
 
 	widgetAction->setDefaultWidget(frame);
 	menu.addAction(widgetAction);
 
     QPoint pos(-menu.sizeHint().width()+m_tbSave->width(),-menu.sizeHint().height());
     menu.exec(m_tbSave->mapToGlobal(pos));
 
 	//TODO: focus is not set. why?
 	leFilename->setFocus();
 }
 
 /*!
  * Is called when the current properties are going to be saved as a new template.
  * Emits \c saveConfigRequested, the receiver of the signal has to config.sync().
  */
 void TemplateHandler::saveNewSelected(const QString& filename) {
     KConfig config(QStandardPaths::locate(QStandardPaths::ApplicationsLocation, "templates") + '/' + m_dirNames.at(m_className) + '/' + filename, KConfig::SimpleConfig);
 	emit saveConfigRequested(config);
 
 	//we have at least one saved template now -> enable the load button
     m_tbLoad->setEnabled(true);
 
 	emit info( i18n("New template \"%1\" was saved.", filename) );
 }
 
 /*!
  * Is called when the current properties are going to be saved in an already available template.
  * Emits \c saveConfigRequested, the receiver of the signal has to config.sync().
  */
 void TemplateHandler::saveMenuSelected(QAction* action) {
 	KConfig config(action->data().toString()+'/'+action->text(), KConfig::SimpleConfig);
 	emit saveConfigRequested(config);
 
 	emit info( i18n("Template \"%1\" was saved.", action->text()) );
 }
 
 /*!
  * Is called when the current properties are going to be saved as new default properties.
  * Emits \c saveConfigRequested, the receiver of the signal has to config.sync().
  */
 void TemplateHandler::saveDefaults() {
 	KConfig config;
 	emit saveConfigRequested(config);
 
 	emit info( i18n("New default template was saved.") );
 }
diff --git a/src/kdefrontend/ThemeHandler.cpp b/src/kdefrontend/ThemeHandler.cpp
index 519e5b2e9..fca4ca610 100644
--- a/src/kdefrontend/ThemeHandler.cpp
+++ b/src/kdefrontend/ThemeHandler.cpp
@@ -1,234 +1,234 @@
 /***************************************************************************
     File                 : ThemeHandler.cpp
     Project              : LabPlot
     Description          : Widget for handling saving and loading of themes
     --------------------------------------------------------------------
     Copyright            : (C) 2016 Prakriti Bhardwaj (p_bhardwaj14@informatik.uni-kl.de)
     Copyright            : (C) 2016-2017 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ThemeHandler.h"
 #include "widgets/ThemesWidget.h"
 
 #include <QDir>
 #include <QDirIterator>
 #include <QFileInfo>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QPushButton>
 #include <QWidgetAction>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include <KMessageBox>
 // #include <KNS3/UploadDialog>
 
 /*!
   \class ThemeHandler
   \brief Provides a widget with buttons for loading of themes.
 
   Emits \c loadConfig() signal that have to be connected
   to the appropriate slots in the backend (plot widgets)
 
   \ingroup kdefrontend
 */
 
 ThemeHandler::ThemeHandler(QWidget* parent) : QWidget(parent) {
-	auto horizontalLayout = new QHBoxLayout(this);
+	auto* horizontalLayout = new QHBoxLayout(this);
 	horizontalLayout->setSpacing(0);
 	horizontalLayout->setMargin(0);
 
 	m_pbLoadTheme = new QPushButton(this);
 	horizontalLayout->addWidget(m_pbLoadTheme);
 	m_pbLoadTheme->setText(i18n("Apply Theme"));
 
 // 	pbSaveTheme = new QPushButton(this);
 // 	horizontalLayout->addWidget(pbSaveTheme);
 // 	pbSaveTheme->setText(i18n("Save Theme"));
 
 /*
 	pbPublishTheme = new QPushButton(this);
 	horizontalLayout->addWidget(pbPublishTheme);
 	pbPublishTheme->setText("Publish Theme");
 	pbPublishTheme->setEnabled(false);
 */
 
 	connect( m_pbLoadTheme, SIGNAL(clicked()), this, SLOT(showPanel()));
 // 	connect( pbSaveTheme, SIGNAL(clicked()), this, SLOT(saveMenu()));
 // 	connect( pbPublishTheme, SIGNAL(clicked()), this, SLOT(publishThemes()));
 
 	//find all available themes files (system wide and user specific local files)
 	//the list m_themeList contains full paths (path + file name)
 	QStringList dirs = QStandardPaths::locateAll(QStandardPaths::DataLocation, "themes", QStandardPaths::LocateDirectory);
 	for (const auto& dir : dirs) {
 		QDirIterator it(dir, QStringList() << QStringLiteral("*"), QDir::Files);
 		while (it.hasNext())
 			m_themeList.append(it.next());
 	}
 
 	m_pbLoadTheme->setEnabled(!m_themeList.isEmpty());
 }
 
 void ThemeHandler::setCurrentTheme(const QString& name) {
 	if (!name.isEmpty()) {
 		m_pbLoadTheme->setText(i18n("Apply theme [active '%1']", name));
 		m_pbLoadTheme->setToolTip(i18n("Theme '%1' is active. Click on the button to change the theme.", name));
 	} else {
 		m_pbLoadTheme->setText(i18n("Apply Theme"));
 		m_pbLoadTheme->setToolTip(i18n("No theme is active. Click on the button to select a theme."));
 	}
 
 	m_currentTheme = name;
 }
 
 void ThemeHandler::loadSelected(const QString& name) {
 	emit loadThemeRequested(name);
 	this->setCurrentTheme(name);
 
 	if (!name.isEmpty())
 		emit info( i18n("Theme \"%1\" was loaded.", name) );
 	else
 		emit info( i18n("Theming deactivated.") );
 
 	//in case a local theme file was loaded (we have write access), allow to publish it
 	//TODO: activate this later
 // 	if (KStandardDirs::checkAccess(themeFilePath, W_OK)) {
 // 		pbPublishTheme->setEnabled(true);
 // 		m_currentLocalTheme = themeFilePath.right(themeFilePath.length() - themeFilePath.lastIndexOf(QDir::separator()) - 1);
 // 	} else {
 // 		pbPublishTheme->setEnabled(false);
 // 		m_currentLocalTheme.clear();
 // 	}
 }
 
 QStringList ThemeHandler::themes() {
 	QStringList dirs = QStandardPaths::locateAll(QStandardPaths::DataLocation, "themes", QStandardPaths::LocateDirectory);
 	QStringList pathList;
 	for (const auto& dir : dirs) {
 		QDirIterator it(dir, QStringList() << QStringLiteral("*"), QDir::Files);
 		while (it.hasNext())
 			pathList.append(it.next());
 	}
 
 	QStringList themeList;
 	for (int i = 0; i < pathList.size(); ++i) {
 		QFileInfo fileinfo(pathList.at(i));
 		themeList.append(fileinfo.fileName().split('.').at(0));
 	}
 	return themeList;
 }
 
 const QString ThemeHandler::themeFilePath(const QString& name) {
 	QStringList dirs = QStandardPaths::locateAll(QStandardPaths::DataLocation, "themes", QStandardPaths::LocateDirectory);
 
 	QStringList themes;
 	for (const auto& dir : dirs) {
 		QDirIterator it(dir, QStringList() << QStringLiteral("*"), QDir::Files);
 		while (it.hasNext())
 			themes.append(it.next());
 	}
 
 	for (int i = 0; i < themes.size(); ++i) {
 		if (themes.at(i).indexOf(name) != -1)
 			return themes.at(i);
 	}
 
 	return QString();
 }
 
 void ThemeHandler::showPanel() {
 	QMenu menu;
 	ThemesWidget themeWidget(&menu);
 	connect(&themeWidget, SIGNAL(themeSelected(QString)), this, SLOT(loadSelected(QString)));
 	connect(&themeWidget, SIGNAL(themeSelected(QString)), &menu, SLOT(close()));
 	connect(&themeWidget, SIGNAL(canceled()), &menu, SLOT(close()));
 
-	auto widgetAction = new QWidgetAction(this);
+	auto* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&themeWidget);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width()+m_pbLoadTheme->width(),-menu.sizeHint().height());
 	menu.setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
 	menu.exec(m_pbLoadTheme->mapToGlobal(pos));
 }
 
 // void ThemeHandler::saveMenu() {
 // 	QMenu menu;
 // 	menu.addSection(i18n("Save As"));
 //
 // 	// add editable action
 // 	QWidgetAction* widgetAction = new QWidgetAction(this);
 // 	QFrame* frame = new QFrame(this);
 // 	QHBoxLayout* layout = new QHBoxLayout(frame);
 //
 // 	QLabel* label = new QLabel(i18n("Enter name:"), frame);
 // 	layout->addWidget(label);
 //
 // 	QLineEdit* leFilename = new QLineEdit("", frame);
 // 	layout->addWidget(leFilename);
 // 	connect(leFilename, SIGNAL(returnPressed(QString)), this, SLOT(saveNewSelected(QString)));
 // 	connect(leFilename, SIGNAL(returnPressed(QString)), &menu, SLOT(close()));
 //
 // 	widgetAction->setDefaultWidget(frame);
 // 	menu.addAction(widgetAction);
 //
 //     QPoint pos(-menu.sizeHint().width() + m_pbSaveTheme->width(), -menu.sizeHint().height());
 //     menu.exec(m_pbSaveTheme->mapToGlobal(pos));
 // 	leFilename->setFocus();
 // }
 
 // void ThemeHandler::saveNewSelected(const QString& filename) {
 // 	KConfig config(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + '/' + "themes" + '/' + filename, KConfig::SimpleConfig);
 // 	emit saveThemeRequested(config);
 // 	emit info( i18n("New theme \"%1\" was saved.", filename) );
 //
 // 	m_currentLocalTheme = filename;
 // 	m_themeList.append(config.name());
 //
 // 	//enable the publish button so the newly created theme can be published
 // 	//TODO: enable this later
 // // 	pbPublishTheme->setEnabled(true);
 // }
 
 /*!
 	opens the dialog to upload the currently selected local theme.
 	The publish button is only enabled if a local theme was loaded or one of the themes was modified and saved locally.
  */
 // void ThemeHandler::publishThemes() {
 // 	int ret = KMessageBox::questionYesNo(this,
 // 			i18n("Do you want to upload your theme %1 to public web server?", m_currentLocalTheme),
 // 			i18n("Publish Theme"));
 // 	if (ret != KMessageBox::Yes)
 // 		return;
 //
 // 	// creating upload dialog
 // 	KNS3::UploadDialog dialog("labplot2_themes.knsrc", this);
 // 	dialog.setUploadFile(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + '/' + "themes" + '/' + m_currentLocalTheme);
 // 	dialog.setUploadName(m_currentLocalTheme);
 // 	//dialog.setDescription(); TODO: allow the user to provide a short description for the theme to be uploaded
 // 	dialog.exec();
 // }
diff --git a/src/kdefrontend/datasources/DatabaseManagerDialog.cpp b/src/kdefrontend/datasources/DatabaseManagerDialog.cpp
index f4993dce9..9461ef9b1 100644
--- a/src/kdefrontend/datasources/DatabaseManagerDialog.cpp
+++ b/src/kdefrontend/datasources/DatabaseManagerDialog.cpp
@@ -1,92 +1,92 @@
 /***************************************************************************
     File                 : DatabaseManagerDialog.cc
     Project              : LabPlot
     Description          : dialog for managing database connections
     --------------------------------------------------------------------
     Copyright            : (C) 2016-2017 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "DatabaseManagerDialog.h"
 #include "DatabaseManagerWidget.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 #include <QDialogButtonBox>
 #include <QTimer>
 
 /*!
 	\class DatabaseManagerDialog
 	\brief dialog for managing database connections
 
 	\ingroup kdefrontend
 */
 DatabaseManagerDialog::DatabaseManagerDialog(QWidget* parent, const QString& conn) : QDialog(parent),
 	mainWidget(new DatabaseManagerWidget(this, conn)), m_changed(false) {
 
 	setWindowIcon(QIcon::fromTheme("network-server-database"));
 	setWindowTitle(i18nc("@title:window", "SQL Database Connections"));
 
 	QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
-	auto layout = new QVBoxLayout(this);
+	auto* layout = new QVBoxLayout(this);
 	layout->addWidget(mainWidget);
 	layout->addWidget(buttonBox);
 
 	connect(mainWidget, &DatabaseManagerWidget::changed, this, &DatabaseManagerDialog::changed);
 	connect(buttonBox->button(QDialogButtonBox::Ok),&QPushButton::clicked, this, &DatabaseManagerDialog::save);
 	connect(buttonBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &DatabaseManagerDialog::close);
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
 	QTimer::singleShot(0, this, &DatabaseManagerDialog::loadSettings);
 }
 
 void DatabaseManagerDialog::loadSettings() {
 	//restore saved settings
 	QApplication::processEvents(QEventLoop::AllEvents, 0);
 	KConfigGroup conf(KSharedConfig::openConfig(), "DatabaseManagerDialog");
 	KWindowConfig::restoreWindowSize(windowHandle(), conf);
 }
 
 QString DatabaseManagerDialog::connection() const {
 	return mainWidget->connection();
 }
 
 DatabaseManagerDialog::~DatabaseManagerDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "DatabaseManagerDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void DatabaseManagerDialog::changed() {
 	setWindowTitle(i18nc("@title:window", "SQL Database Connections  [Changed]"));
 	m_changed = true;
 }
 
 void DatabaseManagerDialog::save() {
 	//ok-button was clicked, save the connections if they were changed
 	if (m_changed)
 		mainWidget->saveConnections();
 }
diff --git a/src/kdefrontend/datasources/FITSOptionsWidget.cpp b/src/kdefrontend/datasources/FITSOptionsWidget.cpp
index 8e23b6f21..5d96db15b 100644
--- a/src/kdefrontend/datasources/FITSOptionsWidget.cpp
+++ b/src/kdefrontend/datasources/FITSOptionsWidget.cpp
@@ -1,181 +1,181 @@
 /***************************************************************************
 File                 : FITSOptionsWidget.cpp
 Project              : LabPlot
 Description          : Widget providing options for the import of FITS data
 --------------------------------------------------------------------
 Copyright            : (C) 2016 Fabian Kristof (fkristofszabolcs@gmail.com)
 Copyright            : (C) 2017 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 "FITSOptionsWidget.h"
 #include "ImportFileWidget.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "backend/lib/macros.h"
 
 FITSOptionsWidget::FITSOptionsWidget(QWidget* parent, ImportFileWidget* fileWidget) : QWidget(parent), m_fileWidget(fileWidget) {
 	ui.setupUi(parent);
 
 	ui.twExtensions->headerItem()->setText(0, i18n("Content"));
 	ui.twExtensions->setSelectionMode(QAbstractItemView::SingleSelection);
 	ui.twExtensions->setAlternatingRowColors(true);
 	ui.twExtensions->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
 	ui.twPreview->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
 	ui.bRefreshPreview->setIcon( QIcon::fromTheme("view-refresh") );
 
 	connect(ui.twExtensions, &QTreeWidget::itemSelectionChanged, this, &FITSOptionsWidget::fitsTreeWidgetSelectionChanged);
 	connect(ui.bRefreshPreview, &QPushButton::clicked, fileWidget, &ImportFileWidget::refreshPreview);
 }
 
 void FITSOptionsWidget::clear() {
 	ui.twExtensions->clear();
 	ui.twPreview->clear();
 }
 
 QString FITSOptionsWidget::currentExtensionName() {
 	QString name;
 
 	if (ui.twExtensions->currentItem() != nullptr && ui.twExtensions->currentItem()->text(0) != i18n("Primary header"))
 		name = ui.twExtensions->currentItem()->text(ui.twExtensions->currentColumn());
 
 	return name;
 }
 
 void FITSOptionsWidget::updateContent(FITSFilter *filter, const QString& fileName) {
 	DEBUG("FITSOptionsWidget::updateContent() file name = " << fileName.toStdString());
 	ui.twExtensions->clear();
 	filter->parseExtensions(fileName, ui.twExtensions, true);
 	DEBUG("FITSOptionsWidget::updateContent() DONE");
 }
 
 /*!
 	updates the selected var name of a NetCDF file when the tree widget item is selected
 */
 //TODO
 void FITSOptionsWidget::fitsTreeWidgetSelectionChanged() {
 	DEBUG("fitsTreeWidgetSelectionChanges()");
 	QDEBUG("SELECTED ITEMS =" << ui.twExtensions->selectedItems());
 
 	if (ui.twExtensions->selectedItems().isEmpty())
 		return;
 
 	QTreeWidgetItem* item = ui.twExtensions->selectedItems().first();
 	int column = ui.twExtensions->currentColumn();
 
 	WAIT_CURSOR;
 	const QString& itemText = item->text(column);
 	QString selectedExtension;
 	int extType = 0;
 	if (itemText.contains(QLatin1String("IMAGE #")) ||
 	        itemText.contains(QLatin1String("ASCII_TBL #")) ||
 	        itemText.contains(QLatin1String("BINARY_TBL #")))
 		extType = 1;
 	else if (!itemText.compare(i18n("Primary header")))
 		extType = 2;
 	if (extType == 0) {
 		if (item->parent() != nullptr) {
 			if (item->parent()->parent() != nullptr)
 				selectedExtension = item->parent()->parent()->text(0) + QLatin1String("[") + item->text(column) + QLatin1String("]");
 		}
 	} else if (extType == 1) {
 		if (item->parent() != nullptr) {
 			if (item->parent()->parent() != nullptr) {
 				bool ok;
 				int hduNum = itemText.rightRef(1).toInt(&ok);
 				selectedExtension = item->parent()->parent()->text(0) + QLatin1String("[") + QString::number(hduNum-1) + QLatin1String("]");
 			}
 		}
 	} else {
 		if (item->parent()->parent() != nullptr)
 			selectedExtension = item->parent()->parent()->text(column);
 	}
 
 	if (!selectedExtension.isEmpty()) {
-		auto filter = dynamic_cast<FITSFilter*>(m_fileWidget->currentFileFilter());
+		auto* filter = dynamic_cast<FITSFilter*>(m_fileWidget->currentFileFilter());
 		bool readFitsTableToMatrix;
 		const QVector<QStringList> importedStrings = filter->readChdu(selectedExtension, &readFitsTableToMatrix, ui.sbPreviewLines->value());
 		emit m_fileWidget->checkedFitsTableToMatrix(readFitsTableToMatrix);
 
 		const int rows = importedStrings.size();
 		ui.twPreview->clear();
 
 		ui.twPreview->setRowCount(rows);
 		int colCount = 0;
 		const int maxColumns = 300;
 		for (int i = 0; i < rows; ++i) {
 			QStringList lineString = importedStrings[i];
 			if (i == 0) {
 				colCount = lineString.size() > maxColumns ? maxColumns : lineString.size();
 				ui.twPreview->setColumnCount(colCount);
 			}
 			colCount = lineString.size() > maxColumns ? maxColumns : lineString.size();
 
 			for (int j = 0; j < colCount; ++j) {
-				auto item = new QTableWidgetItem(lineString[j]);
+				auto* item = new QTableWidgetItem(lineString[j]);
 				ui.twPreview->setItem(i, j, item);
 			}
 		}
 		ui.twPreview->resizeColumnsToContents();
 	}
 	RESET_CURSOR;
 }
 
 /*!
 	return list of selected FITS extension names
 */
 const QStringList FITSOptionsWidget::selectedFITSExtensions() const {
 	QStringList names;
-	for (const auto* item: ui.twExtensions->selectedItems())
+	for (const auto* item : ui.twExtensions->selectedItems())
 		names << item->text(0);
 
 	return names;
 }
 
 const QString FITSOptionsWidget::extensionName(bool* ok) {
 	if (ui.twExtensions->currentItem() != nullptr) {
 		const QTreeWidgetItem* item = ui.twExtensions->currentItem();
 		const int currentColumn = ui.twExtensions->currentColumn();
 		QString itemText = item->text(currentColumn);
 		int extType = 0;
 		if (itemText.contains(QLatin1String("IMAGE #")) ||
 		        itemText.contains(QLatin1String("ASCII_TBL #")) ||
 		        itemText.contains(QLatin1String("BINARY_TBL #")))
 			extType = 1;
 		else if (!itemText.compare(i18n("Primary header")))
 			extType = 2;
 
 		if (extType == 0) {
 			if (item->parent() != nullptr && item->parent()->parent() != nullptr)
 				return item->parent()->parent()->text(0) + QLatin1String("[")+ item->text(currentColumn) + QLatin1String("]");
 		} else if (extType == 1) {
 			if (item->parent() != nullptr && item->parent()->parent() != nullptr) {
 				int hduNum = itemText.rightRef(1).toInt(ok);
 				return item->parent()->parent()->text(0) + QLatin1String("[") + QString::number(hduNum-1) + QLatin1String("]");
 			}
 		} else {
 			if (item->parent()->parent() != nullptr)
 				return item->parent()->parent()->text(currentColumn);
 		}
 	}
 
 	return QString();
 }
diff --git a/src/kdefrontend/datasources/FileInfoDialog.cpp b/src/kdefrontend/datasources/FileInfoDialog.cpp
index d65507f12..778a1f4b3 100644
--- a/src/kdefrontend/datasources/FileInfoDialog.cpp
+++ b/src/kdefrontend/datasources/FileInfoDialog.cpp
@@ -1,208 +1,208 @@
 /***************************************************************************
     File                 : FileInfoDialog.cpp
     Project              : LabPlot
     Description          : import file data dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2009-2018 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2015-2016 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 "FileInfoDialog.h"
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/datasources/filters/AsciiFilter.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "backend/datasources/filters/NgspiceRawAsciiFilter.h"
 
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QIcon>
 #include <QFileInfo>
 #include <QProcess>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 /*!
 \class ImportWidget
 \brief Provides a dialog containing the information about the files to be imported.
 
 \ingroup kdefrontend
 */
 
 FileInfoDialog::FileInfoDialog(QWidget* parent) : QDialog(parent) {
 
 	m_textEditWidget.setReadOnly(true);
 	m_textEditWidget.setLineWrapMode(QTextEdit::NoWrap);
 
-	auto layout = new QVBoxLayout(this);
+	auto* layout = new QVBoxLayout(this);
 	layout->addWidget(&m_textEditWidget);
 
 	QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok);
 	connect(buttonBox, &QDialogButtonBox::rejected, this, &FileInfoDialog::reject);
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &FileInfoDialog::accept);
 
 	layout->addWidget(buttonBox);
 
 	setWindowIcon(QIcon::fromTheme("help-about"));
 	setWindowTitle(i18nc("@title:window", "File Information"));
 	setAttribute(Qt::WA_DeleteOnClose);
 
 	setLayout(layout);
 
 	QTimer::singleShot(0, this, &FileInfoDialog::loadSettings);
 }
 
 void FileInfoDialog::loadSettings() {
 	//restore saved settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "FileInfoDialog");
 	KWindowConfig::restoreWindowSize(windowHandle(), conf);
 }
 
 FileInfoDialog::~FileInfoDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "FileInfoDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void FileInfoDialog::setFiles(QStringList& files) {
 	QString infoString;
 
-	for (const auto& fileName: files) {
+	for (const auto& fileName : files) {
 		if (fileName.isEmpty())
 			continue;
 
 		if (!infoString.isEmpty())
 			infoString += "<br><br><br>";
 
 		infoString += fileInfoString(fileName);
 	}
 
 	m_textEditWidget.document()->setHtml(infoString);
 }
 
 /*!
     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 FileInfoDialog::fileInfoString(const QString& name) const {
 	QString infoString;
 	QFileInfo fileInfo;
 	QString fileTypeString;
 	QIODevice *file = new QFile(name);
 
 	QString fileName;
 #ifdef Q_OS_WIN
 	if (name.at(1) != QLatin1Char(':'))
 		fileName = QDir::homePath() + name;
 	else
 		fileName = name;
 #else
 	if (name.at(0) != QDir::separator())
 		fileName = QDir::homePath() + QDir::separator() + name;
 	else
 		fileName = name;
 #endif
 	if (!file)
 		file = new QFile(fileName);
 
 	if (file->open(QIODevice::ReadOnly)) {
 		QStringList infoStrings;
 		infoStrings << "<u><b>" + fileName + "</b></u><br>";
 
 		// file type and type specific information about the file
 #ifdef Q_OS_LINUX
-		auto proc = new QProcess();
+		auto* 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
 
 		//depending on the file type, generate additional information about the file:
 		infoStrings << "<br>";
 		AbstractFileFilter::FileType fileType = AbstractFileFilter::fileType(fileName);
 		switch (fileType) {
 		case AbstractFileFilter::Ascii:
 			infoStrings << AsciiFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::Binary:
 			//TODO infoStrings << BinaryFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::Image:
 			//TODO infoStrings << ImageFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::HDF5:
 			//TODO infoStrings << HDF5Filter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::NETCDF:
 			//TODO infoStrings << NETCDFFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::FITS:
 			infoStrings << FITSFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::JSON:
 			//TODO infoStrings << JsonFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::ROOT:
 			//TODO infoStrings << ROOTFilter::fileInfoString(fileName);
 			break;
 		case AbstractFileFilter::NgspiceRawAscii:
 		case AbstractFileFilter::NgspiceRawBinary:
 			infoStrings << NgspiceRawAsciiFilter::fileInfoString(fileName);
 			break;
 		}
 
 		//general information about the file
 		infoStrings << "<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()));
 		infoString += infoStrings.join("<br>");
 	} else
 		infoString += i18n("Could not open file %1 for reading.", fileName);
 
 	return infoString;
 }
diff --git a/src/kdefrontend/datasources/HDF5OptionsWidget.cpp b/src/kdefrontend/datasources/HDF5OptionsWidget.cpp
index 0352d08f6..5d9dd2f8e 100644
--- a/src/kdefrontend/datasources/HDF5OptionsWidget.cpp
+++ b/src/kdefrontend/datasources/HDF5OptionsWidget.cpp
@@ -1,103 +1,103 @@
 /***************************************************************************
 File                 : HDF5OptionsWidget.cpp
 Project              : LabPlot
 Description          : widget providing options for the import of HDF5 data
 --------------------------------------------------------------------
 Copyright            : (C) 2015-2017 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 "HDF5OptionsWidget.h"
 #include "ImportFileWidget.h"
 #include "backend/datasources/filters/HDF5Filter.h"
 #include "backend/lib/macros.h"
 
  /*!
 	\class HDF5OptionsWidget
 	\brief Widget providing options for the import of HDF5 data
 
 	\ingroup kdefrontend
  */
 HDF5OptionsWidget::HDF5OptionsWidget(QWidget* parent, ImportFileWidget* fileWidget) : QWidget(parent), m_fileWidget(fileWidget) {
 	ui.setupUi(parent);
 
 	QStringList hdf5headers;
 	hdf5headers << i18n("Name") << i18n("Link") << i18n("Type") << i18n("Properties") << i18n("Attributes");
 	ui.twContent->setHeaderLabels(hdf5headers);
 	ui.twContent->setAlternatingRowColors(true);
 	// link and type column are hidden
 	ui.twContent->hideColumn(1);
 	ui.twContent->hideColumn(2);
 	ui.twContent->setSelectionMode(QAbstractItemView::ExtendedSelection);
 	ui.twContent->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
 	ui.twPreview->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
 	ui.bRefreshPreview->setIcon( QIcon::fromTheme("view-refresh") );
 
 	connect( ui.twContent, SIGNAL(itemSelectionChanged()), SLOT(hdf5TreeWidgetSelectionChanged()) );
 	connect( ui.bRefreshPreview, SIGNAL(clicked()), fileWidget, SLOT(refreshPreview()) );
 }
 
 void HDF5OptionsWidget::clear() {
 	ui.twContent->clear();
 	ui.twPreview->clear();
 }
 
 void HDF5OptionsWidget::updateContent(HDF5Filter *filter, const QString& fileName) {
 	ui.twContent->clear();
 	QTreeWidgetItem *rootItem = ui.twContent->invisibleRootItem();
 	filter->parse(fileName, rootItem);
 
 	ui.twContent->insertTopLevelItem(0, rootItem);
 	ui.twContent->expandAll();
 	ui.twContent->resizeColumnToContents(0);
 	ui.twContent->resizeColumnToContents(3);
 }
 
 /*!
 	updates the selected data set of a HDF5 file when a new tree widget item is selected
 */
 void HDF5OptionsWidget::hdf5TreeWidgetSelectionChanged() {
 	DEBUG("hdf5TreeWidgetSelectionChanged()");
 	auto items = ui.twContent->selectedItems();
 	QDEBUG("SELECTED ITEMS =" << items);
 
 	if (items.isEmpty())
 		return;
 
 	QTreeWidgetItem* item = items.first();
 	if (item->data(2, Qt::DisplayRole).toString() == i18n("data set"))
 		m_fileWidget->refreshPreview();
 	else
 		DEBUG("non data set selected in HDF5 tree widget");
 }
 
 /*!
 	return list of selected HDF5 item names
 */
 const QStringList HDF5OptionsWidget::selectedHDF5Names() const {
 	QStringList names;
 
 	// the data link is saved in the second column
-	for (auto* item: ui.twContent->selectedItems())
+	for (auto* item : ui.twContent->selectedItems())
 		names << item->text(1);
 
 	return names;
 }
diff --git a/src/kdefrontend/datasources/ImportDialog.cpp b/src/kdefrontend/datasources/ImportDialog.cpp
index ea56ec54e..5fc2f5b73 100644
--- a/src/kdefrontend/datasources/ImportDialog.cpp
+++ b/src/kdefrontend/datasources/ImportDialog.cpp
@@ -1,188 +1,188 @@
 /***************************************************************************
     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 "ImportDialog.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/core/Workbook.h"
 #include "backend/lib/macros.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/MainWin.h"
 
 #include <QDir>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QInputDialog>
 #include <QLabel>
 #include <QMenu>
 #include <QProgressBar>
 #include <QStatusBar>
 #include <QToolButton>
 #include <QVBoxLayout>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 
 /*!
 	\class ImportDialog
 	\brief Base class for other import dialogs. Provides the "Import to" section of those dialogs.
 
 	\ingroup kdefrontend
  */
 
 ImportDialog::ImportDialog(MainWin* parent) : QDialog(parent),
 	vLayout(new QVBoxLayout(this)),
 	okButton(nullptr),
 	lPosition(nullptr),
 	cbPosition(nullptr),
 	cbAddTo(nullptr),
 	m_mainWin(parent),
 	frameAddTo(nullptr),
 	tbNewDataContainer(nullptr),
 	m_newDataContainerMenu(nullptr),
 	m_aspectTreeModel(new AspectTreeModel(parent->project())) {
 
 	//menu for new data container
 	m_newDataContainerMenu = new QMenu(this);
 	m_newDataContainerMenu->addAction( QIcon::fromTheme("labplot-workbook-new"), i18n("New Workbook") );
 	m_newDataContainerMenu->addAction( QIcon::fromTheme("labplot-spreadsheet-new"), i18n("New Spreadsheet") );
 	m_newDataContainerMenu->addAction( QIcon::fromTheme("labplot-matrix-new"), i18n("New Matrix") );
 	connect(m_newDataContainerMenu, SIGNAL(triggered(QAction*)), this, SLOT(newDataContainer(QAction*)));
 }
 
 ImportDialog::~ImportDialog() {
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 
 	//save the last used import position for file imports, no need to do this for live data source (cbPosition=0)
 	if (cbPosition) {
 		KConfigGroup conf(KSharedConfig::openConfig(), "ImportDialog");
 		conf.writeEntry("Position", cbPosition->currentIndex());
 	}
 }
 
 /*!
 	creates widgets for the frame "Import-To" and sets the current model in the "Add to"-combobox.
  */
 void ImportDialog::setModel() {
 	//Frame for the "Import To"-Stuff
 	frameAddTo = new QGroupBox(this);
 	frameAddTo->setTitle(i18n("Import to"));
-	auto grid = new QGridLayout(frameAddTo);
+	auto* grid = new QGridLayout(frameAddTo);
 	grid->addWidget(new QLabel(i18n("Data container"), frameAddTo), 0, 0);
 
 	cbAddTo = new TreeViewComboBox(frameAddTo);
 	cbAddTo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 	grid->addWidget(cbAddTo, 0, 1);
 
 	QList<const char*> list;
 	list << "Folder" << "Spreadsheet" << "Matrix"  << "Workbook";
 	cbAddTo->setTopLevelClasses(list);
 
 	list.clear();
 	list << "Spreadsheet" << "Matrix" << "Workbook";
 	m_aspectTreeModel->setSelectableAspects(list);
 
 	cbAddTo->setModel(m_aspectTreeModel);
 
 	tbNewDataContainer = new QToolButton(frameAddTo);
 	tbNewDataContainer->setIcon(QIcon::fromTheme("list-add"));
 	tbNewDataContainer->setToolTip(i18n("Add new data container"));
 	grid->addWidget( tbNewDataContainer, 0, 2);
 
 	lPosition = new QLabel(i18n("Position"), frameAddTo);
 	lPosition->setEnabled(false);
 	grid->addWidget(lPosition, 1, 0);
 
 	cbPosition = new QComboBox(frameAddTo);
 	cbPosition->setEnabled(false);
 	cbPosition->addItem(i18n("Append"));
 	cbPosition->addItem(i18n("Prepend"));
 	cbPosition->addItem(i18n("Replace"));
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportDialog");
 	cbPosition->setCurrentIndex(conf.readEntry("Position", 0));
 
 	cbPosition->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
 	grid->addWidget(cbPosition, 1, 1);
 
 	//add the "Import to"-frame to the layout after the first main widget
 	vLayout->insertWidget(1, frameAddTo);
 
 	connect(tbNewDataContainer, SIGNAL(clicked(bool)), this, SLOT(newDataContainerMenu()));
 	connect(cbAddTo, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(checkOkButton()));
 }
 
 void ImportDialog::setCurrentIndex(const QModelIndex& index) {
 	DEBUG("ImportFileDialog::setCurrentIndex()");
 	QDEBUG(" index =" << index);
 	cbAddTo->setCurrentModelIndex(index);
 	QDEBUG("cbAddTo->currentModelIndex() =" << cbAddTo->currentModelIndex());
 	checkOkButton();
 }
 
 void ImportDialog::newDataContainer(QAction* action) {
 	DEBUG("ImportDialog::newDataContainer()");
 	QString name = selectedObject();
 	QString type = action->iconText().split(' ')[1];
 	if (name.isEmpty())
 		name = action->iconText();
 
 	bool ok;
 	// child widgets can't have own icons
 	QInputDialog* dlg = new QInputDialog(this);
 	name = dlg->getText(this, i18n("Add %1", action->iconText()), i18n("%1 name:", type), QLineEdit::Normal, name, &ok);
 	if (ok) {
 		AbstractAspect* aspect;
 		int actionIndex = m_newDataContainerMenu->actions().indexOf(action);
 		if (actionIndex == 0)
 			aspect = new Workbook(name);
 		else if (actionIndex == 1)
 			aspect = new Spreadsheet(name);
 		else
 			aspect = new Matrix(name);
 
 		m_mainWin->addAspectToProject(aspect);
 		QDEBUG("cbAddTo->setCurrentModelIndex() to " << m_mainWin->model()->modelIndexOfAspect(aspect));
 		cbAddTo->setCurrentModelIndex(m_mainWin->model()->modelIndexOfAspect(aspect));
 		checkOkButton();
 
 		//select "Replace" since this is the most common case when importing into a newly created container
 		cbPosition->setCurrentIndex(2);
 	}
 
 	delete dlg;
 }
 
 void ImportDialog::newDataContainerMenu() {
 	m_newDataContainerMenu->exec( tbNewDataContainer->mapToGlobal(tbNewDataContainer->rect().bottomLeft()));
 }
diff --git a/src/kdefrontend/datasources/ImportFileDialog.cpp b/src/kdefrontend/datasources/ImportFileDialog.cpp
index 9fe8135a3..40d07a931 100644
--- a/src/kdefrontend/datasources/ImportFileDialog.cpp
+++ b/src/kdefrontend/datasources/ImportFileDialog.cpp
@@ -1,514 +1,514 @@
 /***************************************************************************
     File                 : ImportDialog.cc
     Project              : LabPlot
     Description          : import file data dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2008-2018 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/HDF5Filter.h"
 #include "backend/datasources/filters/NetCDFFilter.h"
 #include "backend/datasources/filters/ROOTFilter.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"
 
 #ifdef HAVE_MQTT
 #include "backend/datasources/MQTTClient.h"
 #endif
 
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KWindowConfig>
 #include <KLocalizedString>
 
 #include <QDialogButtonBox>
 #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, liveDataSource, fileName)),
 	m_showOptions(false) {
 
 	vLayout->addWidget(m_importFileWidget);
 
 	//dialog buttons
 	QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Reset |QDialogButtonBox::Cancel);
 	okButton = buttonBox->button(QDialogButtonBox::Ok);
 	m_optionsButton = buttonBox->button(QDialogButtonBox::Reset); //we highjack the default "Reset" button and use if for showing/hiding the options
 	okButton->setEnabled(false); //ok is only available if a valid container was selected
 	vLayout->addWidget(buttonBox);
 
 	//hide the data-source related widgets
 	if (!liveDataSource)
 		setModel();
 
 	//Signals/Slots
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
 	connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
 	if (!liveDataSource)
 		setWindowTitle(i18nc("@title:window", "Import Data to Spreadsheet or Matrix"));
 	else
 		setWindowTitle(i18nc("@title:window", "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);
 	m_importFileWidget->loadSettings();
 
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportFileDialog");
 	m_showOptions = conf.readEntry("ShowOptions", false);
 	m_showOptions ? m_optionsButton->setText(i18n("Hide Options")) : m_optionsButton->setText(i18n("Show Options"));
 	m_importFileWidget->showOptions(m_showOptions);
 
 	//do the signal-slot connections after all settings where loaded in import file widget and check the OK button after this
 	connect(m_importFileWidget, &ImportFileWidget::checkedFitsTableToMatrix, this, &ImportFileDialog::checkOnFitsTableToMatrix);
 	connect(m_importFileWidget, static_cast<void (ImportFileWidget::*)()>(&ImportFileWidget::fileNameChanged), this, &ImportFileDialog::checkOkButton);
 	connect(m_importFileWidget, static_cast<void (ImportFileWidget::*)()>(&ImportFileWidget::sourceTypeChanged), this, &ImportFileDialog::checkOkButton);
 	connect(m_importFileWidget, &ImportFileWidget::hostChanged, this, &ImportFileDialog::checkOkButton);
 	connect(m_importFileWidget, &ImportFileWidget::portChanged, this, &ImportFileDialog::checkOkButton);
 	//TODO: do we really need to check the ok button when the preview was refreshed?
 	//If not, remove this together with the previewRefreshed signal in ImportFileWidget
 	//connect(m_importFileWidget, &ImportFileWidget::previewRefreshed, this, &ImportFileDialog::checkOkButton);
 #ifdef HAVE_MQTT
 	connect(m_importFileWidget, &ImportFileWidget::subscriptionsChanged, this, &ImportFileDialog::checkOkButton);
 	connect(m_importFileWidget, &ImportFileWidget::checkFileType, this, &ImportFileDialog::checkOkButton);
 #endif
 	connect(m_optionsButton, &QPushButton::clicked, this, &ImportFileDialog::toggleOptions);
 
 	checkOkButton();
 
 	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);
 }
 
 int ImportFileDialog::sourceType() const {
 	return static_cast<int>(m_importFileWidget->currentSourceType());
 }
 
 /*!
   triggers data import to the live data source \c source
 */
 void ImportFileDialog::importToLiveDataSource(LiveDataSource* source, QStatusBar* statusBar) const {
 	DEBUG("ImportFileDialog::importToLiveDataSource()");
 	m_importFileWidget->saveSettings(source);
 
 	//show a progress bar in the status bar
-	auto progressBar = new QProgressBar();
+	auto* progressBar = new QProgressBar();
 	progressBar->setRange(0, 100);
-    connect(source->filter(), &AbstractFileFilter::completed, progressBar, &QProgressBar::setValue);
+	connect(source->filter(), &AbstractFileFilter::completed, progressBar, &QProgressBar::setValue);
 
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 	WAIT_CURSOR;
 
 	QTime timer;
 	timer.start();
 	DEBUG("	Initial read()");
 	source->read();
 	statusBar->showMessage( i18n("Live data source created in %1 seconds.", (float)timer.elapsed()/1000) );
 
 	RESET_CURSOR;
 	statusBar->removeWidget(progressBar);
 	source->ready();
 }
 
 #ifdef HAVE_MQTT
 /*!
   triggers data import to the MQTTClient \c client
 */
 void ImportFileDialog::importToMQTT(MQTTClient* client) const{
 	m_importFileWidget->saveMQTTSettings(client);
 	client->read();
 	client->ready();
 }
 #endif
 
 /*!
   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;
 	}
 
 	if (m_importFileWidget->isFileEmpty()) {
 		KMessageBox::information(nullptr, i18n("No data to import."), i18n("No Data"));
 		return;
 	}
 
 	QString fileName = m_importFileWidget->fileName();
 	AbstractFileFilter* filter = m_importFileWidget->currentFileFilter();
 	auto mode = AbstractFileFilter::ImportMode(cbPosition->currentIndex());
 
 	//show a progress bar in the status bar
-	auto progressBar = new QProgressBar();
+	auto* 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")) {
 		DEBUG("	to Matrix");
-		auto matrix = qobject_cast<Matrix*>(aspect);
+		auto* matrix = qobject_cast<Matrix*>(aspect);
 		filter->readDataFromFile(fileName, matrix, mode);
 	} else if (aspect->inherits("Spreadsheet")) {
 		DEBUG("	to Spreadsheet");
-		auto spreadsheet = qobject_cast<Spreadsheet*>(aspect);
+		auto* spreadsheet = qobject_cast<Spreadsheet*>(aspect);
 		DEBUG(" Calling readDataFromFile()");
 		filter->readDataFromFile(fileName, spreadsheet, mode);
 	} else if (aspect->inherits("Workbook")) {
 		DEBUG("	to Workbook");
-		auto workbook = qobject_cast<Workbook*>(aspect);
+		auto* workbook = qobject_cast<Workbook*>(aspect);
 		QVector<AbstractAspect*> sheets = workbook->children<AbstractAspect>();
 
 		AbstractFileFilter::FileType fileType = m_importFileWidget->currentFileType();
 		// multiple data sets/variables for HDF5, NetCDF and ROOT
 		if (fileType == AbstractFileFilter::HDF5 ||
 			fileType == AbstractFileFilter::NETCDF ||
 			fileType == AbstractFileFilter::ROOT) {
 			QStringList names;
 			switch (fileType) {
 				case AbstractFileFilter::HDF5:
 					names = m_importFileWidget->selectedHDF5Names();
 					break;
 				case AbstractFileFilter::NETCDF:
 					names = m_importFileWidget->selectedNetCDFNames();
 					break;
 				case AbstractFileFilter::ROOT:
 					names = m_importFileWidget->selectedROOTNames();
 					break;
 				case AbstractFileFilter::Ascii:
 				case AbstractFileFilter::Binary:
 				case AbstractFileFilter::Image:
 				case AbstractFileFilter::FITS:
 				case AbstractFileFilter::JSON:
 				case AbstractFileFilter::NgspiceRawAscii:
 				case AbstractFileFilter::NgspiceRawBinary:
 					break; // never reached, omit warning
 			}
 
 			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(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) {
 				switch (fileType) {
 					case AbstractFileFilter::HDF5:
 						((HDF5Filter*) filter)->setCurrentDataSetName(names[i]);
 						break;
 					case AbstractFileFilter::NETCDF:
 						((NetCDFFilter*) filter)->setCurrentVarName(names[i]);
 						break;
 					case AbstractFileFilter::ROOT:
 						((ROOTFilter*) filter)->setCurrentHistogram(names[i]);
 						break;
 					case AbstractFileFilter::Ascii:
 					case AbstractFileFilter::Binary:
 					case AbstractFileFilter::Image:
 					case AbstractFileFilter::FITS:
 					case AbstractFileFilter::JSON:
 					case AbstractFileFilter::NgspiceRawAscii:
 					case AbstractFileFilter::NgspiceRawBinary:
 						break; // never reached, omit warning
 				}
 
 				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(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 ? m_optionsButton->setText(i18n("Hide Options")) : m_optionsButton->setText(i18n("Show Options"));
 
 	//resize the dialog
 	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")) {
 			okButton->setEnabled(enable);
 			if (enable)
 				okButton->setToolTip(i18n("Close the dialog and import the data."));
 			else
 				okButton->setToolTip(i18n("Cannot import into a matrix since the data contains non-numerical data."));
 		}
 	}
 }
 
 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) {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Select a data container where the data has to be imported into."));
 			lPosition->setEnabled(false);
 			cbPosition->setEnabled(false);
 			return;
 		} else {
 			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 auto matrix = dynamic_cast<const Matrix*>(aspect);
+			const auto* matrix = dynamic_cast<const Matrix*>(aspect);
 			m_importFileWidget->showAsciiHeaderOptions(matrix == nullptr);
 		}
 	}
 
 	QString fileName = m_importFileWidget->fileName();
 #ifndef HAVE_WINDOWS
 	if (!fileName.isEmpty() && fileName.at(0) != QDir::separator())
 		fileName = QDir::homePath() + QDir::separator() + fileName;
 #endif
 
 	DEBUG("Data Source Type: " << ENUM_TO_STRING(LiveDataSource, SourceType, m_importFileWidget->currentSourceType()));
 	switch (m_importFileWidget->currentSourceType()) {
 	case LiveDataSource::SourceType::FileOrPipe: {
 		DEBUG("fileName = " << fileName.toUtf8().constData());
 		const bool enable = QFile::exists(fileName);
 		okButton->setEnabled(enable);
 		if (enable)
 			okButton->setToolTip(i18n("Close the dialog and import the data."));
 		else
 			okButton->setToolTip(i18n("Provide an existing file."));
 
 		break;
 	}
 	case LiveDataSource::SourceType::LocalSocket: {
 		const bool enable = QFile::exists(fileName);
 		if (enable) {
 			QLocalSocket lsocket{this};
 			DEBUG("CONNECT");
 			lsocket.connectToServer(fileName, QLocalSocket::ReadOnly);
 			if (lsocket.waitForConnected()) {
 
 				// this is required for server that send data as soon as connected
 				lsocket.waitForReadyRead();
 
 				DEBUG("DISCONNECT");
 				lsocket.disconnectFromServer();
 				// read-only socket is disconnected immediately (no waitForDisconnected())
 				okButton->setEnabled(true);
 				okButton->setToolTip(i18n("Close the dialog and import the data."));
 			} else {
 				DEBUG("failed connect to local socket - " << lsocket.errorString().toStdString());
 				okButton->setEnabled(false);
 				okButton->setToolTip(i18n("Could not connect to the provided local socket."));
 			}
 		} else {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Selected local socket does not exist."));
 		}
 
 		break;
 	}
 	case LiveDataSource::SourceType::NetworkTcpSocket: {
 		const bool enable = !m_importFileWidget->host().isEmpty() && !m_importFileWidget->port().isEmpty();
 		if (enable) {
 			QTcpSocket socket(this);
 			socket.connectToHost(m_importFileWidget->host(), m_importFileWidget->port().toUShort(), QTcpSocket::ReadOnly);
 			if (socket.waitForConnected()) {
 				okButton->setEnabled(true);
 				okButton->setToolTip(i18n("Close the dialog and import the data."));
 				socket.disconnectFromHost();
 			} else {
 				DEBUG("failed to connect to TCP socket - " << socket.errorString().toStdString());
 				okButton->setEnabled(false);
 				okButton->setToolTip(i18n("Could not connect to the provided TCP socket."));
 			}
 		} else {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Either the host name or the port number is missing."));
 		}
 		break;
 	}
 	case LiveDataSource::SourceType::NetworkUdpSocket: {
 		const bool enable = !m_importFileWidget->host().isEmpty() && !m_importFileWidget->port().isEmpty();
 		if (enable) {
 			QUdpSocket socket(this);
 			socket.bind(QHostAddress(m_importFileWidget->host()), m_importFileWidget->port().toUShort());
 			socket.connectToHost(m_importFileWidget->host(), 0, QUdpSocket::ReadOnly);
 			if (socket.waitForConnected()) {
 				okButton->setEnabled(true);
 				okButton->setToolTip(i18n("Close the dialog and import the data."));
 				socket.disconnectFromHost();
 				// read-only socket is disconnected immediately (no waitForDisconnected())
 			} else {
 				DEBUG("failed to connect to UDP socket - " << socket.errorString().toStdString());
 				okButton->setEnabled(false);
 				okButton->setToolTip(i18n("Could not connect to the provided UDP socket."));
 			}
 		} else {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Either the host name or the port number is missing."));
 		}
 
 		break;
 	}
 	case LiveDataSource::SourceType::SerialPort: {
 		const QString sPort = m_importFileWidget->serialPort();
 		const int baudRate = m_importFileWidget->baudRate();
 
 		if (!sPort.isEmpty()) {
 			QSerialPort serialPort{this};
 
 			DEBUG("	Port: " << sPort.toStdString() << ", Settings: " << baudRate << ',' << serialPort.dataBits()
 					<< ',' << serialPort.parity() << ',' << serialPort.stopBits());
 			serialPort.setPortName(sPort);
 			serialPort.setBaudRate(baudRate);
 
 			const bool serialPortOpened = serialPort.open(QIODevice::ReadOnly);
 			okButton->setEnabled(serialPortOpened);
 			if (serialPortOpened) {
 				okButton->setToolTip(i18n("Close the dialog and import the data."));
 				serialPort.close();
 			} else {
 				DEBUG("Could not connect to the provided serial port");
 				okButton->setToolTip(i18n("Could not connect to the provided serial port."));
 			}
 		} else {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Serial port number is missing."));
 		}
 		break;
     }
 	case LiveDataSource::SourceType::MQTT: {
 #ifdef HAVE_MQTT
 		const bool enable = m_importFileWidget->isMqttValid();
 		if (enable) {
 			okButton->setEnabled(true);
 			okButton->setToolTip(i18n("Close the dialog and import the data."));
 		}
 		else {
 			okButton->setEnabled(false);
 			okButton->setToolTip(i18n("Either there is no connection, or no subscriptions were made, or the file filter is not ASCII."));
 		}
 #endif
 		break;
 	}
 	}
 }
 
 QString ImportFileDialog::selectedObject() const {
 	return m_importFileWidget->selectedObject();
 }
diff --git a/src/kdefrontend/datasources/ImportFileWidget.cpp b/src/kdefrontend/datasources/ImportFileWidget.cpp
index 1475bcd05..d7b1554a6 100644
--- a/src/kdefrontend/datasources/ImportFileWidget.cpp
+++ b/src/kdefrontend/datasources/ImportFileWidget.cpp
@@ -1,2918 +1,2917 @@
 /***************************************************************************
 File                 : ImportFileWidget.cpp
 Project              : LabPlot
 Description          : import file data widget
 --------------------------------------------------------------------
 Copyright            : (C) 2009-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
 Copyright            : (C) 2009-2018 Alexander Semke (alexander.semke@web.de)
 Copyright            : (C) 2017-2018 Fabian Kristof (fkristofszabolcs@gmail.com)
 Copyright            : (C) 2018 Kovacs Ferencz (kferike98@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/HDF5Filter.h"
 #include "backend/datasources/filters/NetCDFFilter.h"
 #include "backend/datasources/filters/ImageFilter.h"
 #include "backend/datasources/filters/FITSFilter.h"
 #include "backend/datasources/filters/JsonFilter.h"
 #include "backend/datasources/filters/QJsonModel.h"
 #include "backend/datasources/filters/NgspiceRawAsciiFilter.h"
 #include "backend/datasources/filters/NgspiceRawBinaryFilter.h"
 #include "backend/datasources/filters/ROOTFilter.h"
 #include "AsciiOptionsWidget.h"
 #include "BinaryOptionsWidget.h"
 #include "HDF5OptionsWidget.h"
 #include "ImageOptionsWidget.h"
 #include "NetCDFOptionsWidget.h"
 #include "FITSOptionsWidget.h"
 #include "JsonOptionsWidget.h"
 #include "ROOTOptionsWidget.h"
 
 #include <QCompleter>
 #include <QDir>
 #include <QDirModel>
 #include <QFileDialog>
 #include <QImageReader>
 #include <QInputDialog>
 #include <QIntValidator>
 #include <QLocalSocket>
 #include <QJsonDocument>
 #include <QProcess>
 #include <QStandardItemModel>
 #include <QTableWidget>
 #include <QTcpSocket>
 #include <QTimer>
 #include <QUdpSocket>
 #include <QCheckBox>
 #include <QTreeWidgetItem>
 #include <QStringList>
 #include <QBuffer>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #ifdef HAVE_MQTT
 #include "kdefrontend/widgets/MQTTWillSettingsWidget.h"
 #include "MQTTConnectionManagerDialog.h"
 #include "MQTTConnectionManagerWidget.h"
 #include "backend/core/Project.h"
 #include <QMqttClient>
 #include <QMqttSubscription>
 #include <QMqttTopicFilter>
 #include <QMqttMessage>
 #include <QMessageBox>
 #include <QWidgetAction>
 #include <QMenu>
 #endif
 
 /*!
    \class ImportFileWidget
    \brief Widget for importing data from a file.
 
    \ingroup kdefrontend
 */
 ImportFileWidget::ImportFileWidget(QWidget* parent, bool liveDataSource, const QString& fileName) : QWidget(parent),
 	m_asciiOptionsWidget(nullptr),
 	m_binaryOptionsWidget(nullptr),
 	m_hdf5OptionsWidget(nullptr),
 	m_imageOptionsWidget(nullptr),
 	m_netcdfOptionsWidget(nullptr),
 	m_fitsOptionsWidget(nullptr),
 	m_jsonOptionsWidget(nullptr),
 	m_rootOptionsWidget(nullptr),
 	m_fileName(fileName),
 	m_fileEmpty(false),
 	m_liveDataSource(liveDataSource),
 	m_suppressRefresh(false)
 #ifdef HAVE_MQTT
 	,
 	m_client(nullptr),
 	m_searching(false),
 	m_searchTimer(new QTimer(this)),
 	m_connectTimeoutTimer(new QTimer(this)),
 	m_mqttReadyForPreview (false),
 	m_initialisingMQTT(false),
 	m_connectionTimedOut(false)
 #endif
 {
 	ui.setupUi(this);
 
-	auto completer = new QCompleter(this);
+	auto* completer = new QCompleter(this);
 	completer->setModel(new QDirModel);
 	ui.leFileName->setCompleter(completer);
 
 	//add supported file types
 	if (!liveDataSource) {
 		ui.cbFileType->addItem(i18n("ASCII data"), AbstractFileFilter::Ascii);
 		ui.cbFileType->addItem(i18n("Binary data"), AbstractFileFilter::Binary);
 		ui.cbFileType->addItem(i18n("Image"), AbstractFileFilter::Image);
 #ifdef HAVE_HDF5
 		ui.cbFileType->addItem(i18n("Hierarchical Data Format 5 (HDF5)"), AbstractFileFilter::HDF5);
 #endif
 #ifdef HAVE_NETCDF
 		ui.cbFileType->addItem(i18n("Network Common Data Format (NetCDF)"), AbstractFileFilter::NETCDF);
 #endif
 #ifdef HAVE_FITS
 		ui.cbFileType->addItem(i18n("Flexible Image Transport System Data Format (FITS)"), AbstractFileFilter::FITS);
 #endif
 		ui.cbFileType->addItem(i18n("JSON data"), AbstractFileFilter::JSON);
 #ifdef HAVE_ZIP
 		ui.cbFileType->addItem(i18n("ROOT (CERN) Histograms"), AbstractFileFilter::ROOT);
 #endif
 		ui.cbFileType->addItem(i18n("Ngspice RAW ASCII"), AbstractFileFilter::NgspiceRawAscii);
 		ui.cbFileType->addItem(i18n("Ngspice RAW Binary"), AbstractFileFilter::NgspiceRawBinary);
 
 		//hide widgets relevant for live data reading only
 		ui.lSourceType->hide();
 		ui.cbSourceType->hide();
 		ui.gbUpdateOptions->hide();
 	} else {
 		ui.cbFileType->addItem(i18n("ASCII data"), AbstractFileFilter::Ascii);
 		ui.cbFileType->addItem(i18n("Binary data"), AbstractFileFilter::Binary);
 		ui.cbFileType->addItem(i18n("Ngspice RAW ASCII"), AbstractFileFilter::NgspiceRawAscii);
 		ui.cbFileType->addItem(i18n("Ngspice RAW Binary"), AbstractFileFilter::NgspiceRawBinary);
 
 		ui.lePort->setValidator( new QIntValidator(ui.lePort) );
 		ui.cbBaudRate->addItems(LiveDataSource::supportedBaudRates());
 		ui.cbSerialPort->addItems(LiveDataSource::availablePorts());
 
 		ui.tabWidget->removeTab(2);
 
 #ifdef HAVE_MQTT
 		m_searchTimer->setInterval(10000);
 		m_connectTimeoutTimer->setInterval(6000);
 #endif
 	}
 
 	QStringList filterItems {i18n("Automatic"), i18n("Custom")};
 	ui.cbFilter->addItems(filterItems);
 
 	//hide options that will be activated on demand
 	ui.gbOptions->hide();
 	ui.gbUpdateOptions->hide();
 	setMQTTVisible(false);
 
 	ui.cbReadingType->addItem(i18n("Whole file"), LiveDataSource::WholeFile);
 
 	ui.bOpen->setIcon( QIcon::fromTheme(QLatin1String("document-open")) );
 	ui.bFileInfo->setIcon( QIcon::fromTheme(QLatin1String("help-about")) );
 	ui.bManageFilters->setIcon( QIcon::fromTheme(QLatin1String("configure")) );
 	ui.bSaveFilter->setIcon( QIcon::fromTheme(QLatin1String("document-save")) );
 	ui.bRefreshPreview->setIcon( QIcon::fromTheme(QLatin1String("view-refresh")) );
 
 	ui.tvJson->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
 	ui.tvJson->setAlternatingRowColors(true);
 	showJsonModel(false);
 
 	// the table widget for preview
 	m_twPreview = new QTableWidget(ui.tePreview);
 	m_twPreview->verticalHeader()->hide();
 	m_twPreview->setEditTriggers(QTableWidget::NoEditTriggers);
-	auto layout = new QHBoxLayout;
+	auto* layout = new QHBoxLayout;
 	layout->addWidget(m_twPreview);
 	ui.tePreview->setLayout(layout);
 	m_twPreview->hide();
 
 #ifdef HAVE_MQTT
 	ui.cbSourceType->addItem(QLatin1String("MQTT"));
 	m_configPath = QStandardPaths::standardLocations(QStandardPaths::AppDataLocation).constFirst() +  "MQTT_connections";
 
 	m_willSettings.MQTTUseWill = false;
 	m_willSettings.willRetain = false;
 	m_willSettings.willOwnMessage = QString();
 	m_willSettings.willQoS = 0;
 	m_willSettings.willMessageType = MQTTClient::WillMessageType::OwnMessage;
 	m_willSettings.willUpdateType = MQTTClient::WillUpdateType::TimePeriod;
 	m_willSettings.willTimeInterval = 10000;
 	m_willSettings.willTopic = QString();
 	m_willSettings.willLastMessage = QString();
 	m_willSettings.willStatistics.fill(false, 15);
 
 	ui.bSubscribe->setIcon(ui.bSubscribe->style()->standardIcon(QStyle::SP_ArrowRight));
 	ui.bSubscribe->setToolTip(i18n("Subscribe selected topics"));
 	ui.bUnsubscribe->setIcon(ui.bUnsubscribe->style()->standardIcon(QStyle::SP_ArrowLeft));
 	ui.bUnsubscribe->setToolTip(i18n("Unsubscribe selected topics"));
 	ui.bManageConnections->setIcon(QIcon::fromTheme(QLatin1String("network-server")));
 	ui.bManageConnections->setToolTip(i18n("Manage MQTT connections"));
 	ui.bWillMessage->setEnabled(false);
 	ui.bWillMessage->setToolTip(i18n("Manage MQTT connection's will settings"));
 	ui.bWillMessage->setIcon(ui.bWillMessage->style()->standardIcon(QStyle::SP_FileDialogDetailedView));
 #endif
 
 	//TODO: implement save/load of user-defined settings later and activate these buttons again
 	ui.bSaveFilter->hide();
 	ui.bManageFilters->hide();
 }
 
 void ImportFileWidget::loadSettings() {
 	m_suppressRefresh = true;
 
 	//load last used settings
 	QString confName;
 	if (m_liveDataSource)
 		confName = QLatin1String("LiveDataImport");
 	else
 		confName = QLatin1String("FileImport");
 	KConfigGroup conf(KSharedConfig::openConfig(), confName);
 
 	//read the source type first since settings in fileNameChanged() depend on this
 	ui.cbSourceType->setCurrentIndex(conf.readEntry("SourceType").toInt());
 
 	//general settings
 	AbstractFileFilter::FileType fileType = static_cast<AbstractFileFilter::FileType>(conf.readEntry("Type", 0));
 	for (int i = 0; i < ui.cbFileType->count(); ++i) {
 		AbstractFileFilter::FileType itemFileType = static_cast<AbstractFileFilter::FileType>(ui.cbFileType->itemData(i).toInt());
 		if (itemFileType == fileType) {
 			ui.cbFileType->setCurrentIndex(i);
 			break;
 		}
 	}
 
 	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.cbReadingType->setCurrentIndex(conf.readEntry("ReadingType").toInt());
 	ui.cbSerialPort->setCurrentIndex(conf.readEntry("SerialPort").toInt());
 	ui.cbUpdateType->setCurrentIndex(conf.readEntry("UpdateType").toInt());
 	ui.leHost->setText(conf.readEntry("Host",""));
 	ui.sbKeepNValues->setValue(conf.readEntry("KeepNValues").toInt());
 	ui.lePort->setText(conf.readEntry("Port",""));
 	ui.sbSampleSize->setValue(conf.readEntry("SampleSize").toInt());
 	ui.sbUpdateInterval->setValue(conf.readEntry("UpdateInterval").toInt());
 
 #ifdef HAVE_MQTT
 	//MQTT related settings
 	//read available connections
 	m_initialisingMQTT = true;
 	readMQTTConnections();
 
 	ui.cbConnection->setCurrentIndex(ui.cbConnection->findText(conf.readEntry("Connection", "")));
 
 	m_willSettings.willRetain = conf.readEntry("mqttWillRetain").toInt();
 	m_willSettings.willUpdateType = static_cast<MQTTClient::WillUpdateType>(conf.readEntry("mqttWillUpdateType").toInt());
 	m_willSettings.willQoS = conf.readEntry("mqttWillQoS").toInt();
 	m_willSettings.willOwnMessage = conf.readEntry("mqttWillOwnMessage","");
 	m_willSettings.willTimeInterval = conf.readEntry("mqttWillUpdateInterval","").toInt();
 	QString willStatistics = conf.readEntry("mqttWillStatistics","");
 	QStringList statisticsList = willStatistics.split('|', QString::SplitBehavior::SkipEmptyParts);
 	for (auto value : statisticsList) {
 		m_willSettings.willStatistics[value.toInt()] = true;
 	}
 	m_willSettings.willMessageType = static_cast<MQTTClient::WillMessageType>(conf.readEntry("mqttWillMessageType").toInt());
 	m_willSettings.MQTTUseWill = conf.readEntry("mqttWillUse").toInt();
 
 	m_initialisingMQTT = false;
 #endif
 
 	//initialize the slots after all settings were set in order to avoid unneeded refreshes
 	initSlots();
 
 	//update the status of the widgets
 	sourceTypeChanged(currentSourceType());
 	fileTypeChanged(fileType);
 	readingTypeChanged(ui.cbReadingType->currentIndex());
 
 	//all set now, refresh the preview
 	m_suppressRefresh = false;
 	QTimer::singleShot(100, this, [=] () { refreshPreview(); });
 }
 
 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", (int)currentFileType());
 	conf.writeEntry("Filter", ui.cbFilter->currentIndex());
 	conf.writeEntry("LastImportedFile", ui.leFileName->text());
 
 	//live data related settings
 	conf.writeEntry("SourceType", (int)currentSourceType());
 	conf.writeEntry("UpdateType", ui.cbUpdateType->currentIndex());
 	conf.writeEntry("ReadingType", ui.cbReadingType->currentIndex());
 	conf.writeEntry("SampleSize", ui.sbSampleSize->value());
 	conf.writeEntry("KeepNValues", ui.sbKeepNValues->value());
 	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());
 
 #ifdef HAVE_MQTT
 	//MQTT related settings
 	conf.writeEntry("Connection", ui.cbConnection->currentText());
 	conf.writeEntry("mqttWillMessageType", static_cast<int>(m_willSettings.willMessageType));
 	conf.writeEntry("mqttWillUpdateType", static_cast<int>(m_willSettings.willUpdateType));
 	conf.writeEntry("mqttWillQoS", QString::number(m_willSettings.willQoS));
 	conf.writeEntry("mqttWillOwnMessage", m_willSettings.willOwnMessage);
 	conf.writeEntry("mqttWillUpdateInterval", QString::number(m_willSettings.willTimeInterval));
 	QString willStatistics;
 	for (int i = 0; i < m_willSettings.willStatistics.size(); ++i) {
 		if (m_willSettings.willStatistics[i])
 			willStatistics += QString::number(i)+"|";
 	}
 	conf.writeEntry("mqttWillStatistics", willStatistics);
 	conf.writeEntry("mqttWillRetain", static_cast<int>(m_willSettings.willRetain));
 	conf.writeEntry("mqttWillUse", static_cast<int>(m_willSettings.MQTTUseWill));
 #endif
 
 	// data type specific settings
 	if (m_asciiOptionsWidget)
 		m_asciiOptionsWidget->saveSettings();
 	if (m_binaryOptionsWidget)
 		m_binaryOptionsWidget->saveSettings();
 	if (m_imageOptionsWidget)
 		m_imageOptionsWidget->saveSettings();
 	if (m_jsonOptionsWidget)
 		m_jsonOptionsWidget->saveSettings();
 }
 
 void ImportFileWidget::initSlots() {
 	//SLOTs for the general part of the data source configuration
 	connect( ui.cbSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(sourceTypeChanged(int)));
 	connect( ui.leFileName, SIGNAL(textChanged(QString)), SLOT(fileNameChanged(QString)) );
 	connect(ui.leHost, SIGNAL(textChanged(QString)), this, SIGNAL(hostChanged()));
 	connect(ui.lePort, SIGNAL(textChanged(QString)), this, SIGNAL(portChanged()));
 	connect( ui.tvJson, SIGNAL(clicked(QModelIndex)), this, SLOT(refreshPreview()));
 	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.cbReadingType, SIGNAL(currentIndexChanged(int)), this, SLOT(readingTypeChanged(int)));
 	connect( ui.cbFilter, SIGNAL(activated(int)), SLOT(filterChanged(int)) );
 	connect( ui.bRefreshPreview, SIGNAL(clicked()), SLOT(refreshPreview()) );
 
 #ifdef HAVE_MQTT
 	connect(ui.cbConnection, static_cast<void (QComboBox::*) (int)>(&QComboBox::currentIndexChanged), this, &ImportFileWidget::mqttConnectionChanged);
 	connect(ui.bSubscribe,  &QPushButton::clicked, this, &ImportFileWidget::mqttSubscribe);
 	connect(ui.bUnsubscribe, &QPushButton::clicked, this,&ImportFileWidget::mqttUnsubscribe);
 	connect(this, &ImportFileWidget::newTopic, this, &ImportFileWidget::setTopicCompleter);
 	connect(m_searchTimer, &QTimer::timeout, this, &ImportFileWidget::topicTimeout);
 	connect(m_connectTimeoutTimer, &QTimer::timeout, this, &ImportFileWidget::mqttConnectTimeout);
 	connect(ui.cbFileType, static_cast<void (QComboBox::*) (int)>(&QComboBox::currentIndexChanged), [this]() {emit checkFileType();});
 	connect(ui.leTopics, &QLineEdit::textChanged, this, &ImportFileWidget::scrollToTopicTreeItem);
 	connect(ui.leSubscriptions, &QLineEdit::textChanged, this, &ImportFileWidget::scrollToSubsriptionTreeItem);
 	connect(ui.bManageConnections, &QPushButton::clicked, this, &ImportFileWidget::showMQTTConnectionManager);
 	connect(ui.bWillMessage, &QPushButton::clicked, this, &ImportFileWidget::showWillSettings);
 #endif
 }
 
 void ImportFileWidget::showAsciiHeaderOptions(bool b) {
 	if (m_asciiOptionsWidget)
 		m_asciiOptionsWidget->showAsciiHeaderOptions(b);
 }
 
 void ImportFileWidget::showJsonModel(bool b) {
 	ui.tvJson->setVisible(b);
 	ui.lField->setVisible(b);
 }
 
 void ImportFileWidget::showOptions(bool b) {
 	ui.gbOptions->setVisible(b);
 
 	if (m_liveDataSource)
 		ui.gbUpdateOptions->setVisible(b);
 
 	resize(layout()->minimumSize());
 }
 
 QString ImportFileWidget::fileName() const {
 	return ui.leFileName->text();
 }
 
 QString ImportFileWidget::selectedObject() const {
 	const QString& path = ui.leFileName->text();
 
 	//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('.'));
 
 	//for multi-dimensinal formats like HDF, netCDF and FITS add the currently selected object
 	const auto format = currentFileType();
 	if (format == AbstractFileFilter::HDF5) {
 		const QStringList& hdf5Names = m_hdf5OptionsWidget->selectedHDF5Names();
 		if (hdf5Names.size())
 			name += hdf5Names.first(); //the names of the selected HDF5 objects already have '/'
 	} else if (format == AbstractFileFilter::NETCDF) {
 		const QStringList& names = m_netcdfOptionsWidget->selectedNetCDFNames();
 		if (names.size())
 			name += QLatin1Char('/') + names.first();
 	} else if (format == AbstractFileFilter::FITS) {
 		const QString& extensionName = m_fitsOptionsWidget->currentExtensionName();
 		if (!extensionName.isEmpty())
 			name += QLatin1Char('/') + extensionName;
 	} else if (format == AbstractFileFilter::ROOT) {
 		const QStringList& names = m_rootOptionsWidget->selectedROOTNames();
 		if (names.size())
 			name += QLatin1Char('/') + names.first();
 	}
 
 	return name;
 }
 
 /*!
  * 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 {
 	AbstractFileFilter::FileType fileType = currentFileType();
 	auto updateType = static_cast<LiveDataSource::UpdateType>(ui.cbUpdateType->currentIndex());
 	LiveDataSource::SourceType sourceType = currentSourceType();
 	auto readingType = static_cast<LiveDataSource::ReadingType>(ui.cbReadingType->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);
 
 	source->setKeepNValues(ui.sbKeepNValues->value());
 
 	source->setUpdateType(updateType);
 
 	if (readingType != LiveDataSource::ReadingType::TillEnd)
 		source->setSampleSize(ui.sbSampleSize->value());
 
 	switch (sourceType) {
 	case LiveDataSource::SourceType::FileOrPipe:
 		source->setFileName(ui.leFileName->text());
 		source->setFileLinked(ui.chbLinkFile->isChecked());
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
 		source->setFileName(ui.leFileName->text());
 		source->setLocalSocketName(ui.leFileName->text());
 		break;
 	case LiveDataSource::SourceType::NetworkTcpSocket:
 	case LiveDataSource::SourceType::NetworkUdpSocket:
 		source->setHost(ui.leHost->text());
 		source->setPort((quint16)ui.lePort->text().toInt());
 		break;
 	case LiveDataSource::SourceType::SerialPort:
 		source->setBaudRate(ui.cbBaudRate->currentText().toInt());
 		source->setSerialPort(ui.cbSerialPort->currentText());
 		break;
 	case LiveDataSource::SourceType::MQTT:
 		break;
 	default:
 		break;
 	}
 }
 
 #ifdef HAVE_MQTT
 /*!
 	saves the settings to the MQTTClient \c client.
 */
 void ImportFileWidget::saveMQTTSettings(MQTTClient* client) const {
 	DEBUG("ImportFileWidget::saveMQTTSettings");
 	MQTTClient::UpdateType updateType = static_cast<MQTTClient::UpdateType>(ui.cbUpdateType->currentIndex());
 	MQTTClient::ReadingType readingType = static_cast<MQTTClient::ReadingType>(ui.cbReadingType->currentIndex());
 
 	client->setComment( ui.leFileName->text() );
 	client->setFilter(this->currentFileFilter());
 
 	client->setReadingType(readingType);
 
 	if (updateType == MQTTClient::UpdateType::TimeInterval)
 		client->setUpdateInterval(ui.sbUpdateInterval->value());
 
 	client->setKeepNValues(ui.sbKeepNValues->value());
 
 	client->setUpdateType(updateType);
 
 	if (readingType != MQTTClient::ReadingType::TillEnd)
 		client->setSampleSize(ui.sbSampleSize->value());
 
 	client->setMQTTClientHostPort(m_client->hostname(), m_client->port());
 
 	KConfig config(m_configPath, KConfig::SimpleConfig);
 	KConfigGroup group = config.group(ui.cbConnection->currentText());
 
 	bool useID = group.readEntry("UseID").toUInt();
 	bool useAuthentication = group.readEntry("UseAuthentication").toUInt();
 
 	client->setMQTTUseAuthentication(useAuthentication);
 	if (useAuthentication)
 		client->setMQTTClientAuthentication(m_client->username(), m_client->password());
 
 	client->setMQTTUseID(useID);
 	if (useID)
 		client->setMQTTClientId(m_client->clientId());
 
 	for (int i = 0; i < m_mqttSubscriptions.count(); ++i) {
 		client->addInitialMQTTSubscriptions(m_mqttSubscriptions[i]->topic(), m_mqttSubscriptions[i]->qos());
 	}
 
 	bool retain = group.readEntry("Retain").toUInt();
 	client->setMQTTRetain(retain);
 
 	client->setWillSettings(m_willSettings);
 }
 #endif
 
 /*!
 	returns the currently used file type.
 */
 AbstractFileFilter::FileType ImportFileWidget::currentFileType() const {
 	return static_cast<AbstractFileFilter::FileType>( ui.cbFileType->itemData(ui.cbFileType->currentIndex()).toInt() );
 }
 
 LiveDataSource::SourceType ImportFileWidget::currentSourceType() const {
 	return static_cast<LiveDataSource::SourceType>(ui.cbSourceType->currentIndex());
 }
 
 /*!
 	returns the currently used filter.
 */
 AbstractFileFilter* ImportFileWidget::currentFileFilter() const {
 	DEBUG("ImportFileWidget::currentFileFilter()");
 	AbstractFileFilter::FileType fileType = currentFileType();
 
 	switch (fileType) {
 	case AbstractFileFilter::Ascii: {
 		DEBUG("	ASCII");
 		//TODO			std::unique_ptr<AsciiFilter> filter(new AsciiFilter());
-		auto filter = new AsciiFilter();
+		auto* filter = new AsciiFilter();
 
 		if (ui.cbFilter->currentIndex() == 0)     //"automatic"
 			filter->setAutoModeEnabled(true);
 		else if (ui.cbFilter->currentIndex() == 1) { //"custom"
 			filter->setAutoModeEnabled(false);
 			if (m_asciiOptionsWidget)
 				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 AbstractFileFilter::Binary: {
-		auto filter = new BinaryFilter();
+		auto* filter = new BinaryFilter();
 		if ( ui.cbFilter->currentIndex() == 0 ) 	//"automatic"
 			filter->setAutoModeEnabled(true);
 		else if ( ui.cbFilter->currentIndex() == 1 ) {	//"custom"
 			filter->setAutoModeEnabled(false);
 			if (m_binaryOptionsWidget)
 				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 AbstractFileFilter::Image: {
-		auto filter = new ImageFilter();
+		auto* 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 AbstractFileFilter::HDF5: {
-		auto filter = new HDF5Filter();
+		auto* filter = new HDF5Filter();
 		QStringList names = selectedHDF5Names();
 		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 AbstractFileFilter::NETCDF: {
-		auto filter = new NetCDFFilter();
+		auto* 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 AbstractFileFilter::FITS: {
-		auto filter = new FITSFilter();
+		auto* 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;
 	}
 	case AbstractFileFilter::JSON: {
-		auto filter = new JsonFilter();
+		auto* filter = new JsonFilter();
 		m_jsonOptionsWidget->applyFilterSettings(filter, ui.tvJson->currentIndex());
 
 		filter->setStartRow( ui.sbStartRow->value() );
 		filter->setEndRow( ui.sbEndRow->value() );
 		filter->setStartColumn( ui.sbStartColumn->value());
 		filter->setEndColumn( ui.sbEndColumn->value());
 		return filter;
 	}
 	case AbstractFileFilter::ROOT: {
-		auto filter = new ROOTFilter();
+		auto* filter = new ROOTFilter();
 		QStringList names = selectedROOTNames();
 		if (!names.isEmpty())
 			filter->setCurrentHistogram(names.first());
 
 		filter->setStartBin( m_rootOptionsWidget->startBin() );
 		filter->setEndBin( m_rootOptionsWidget->endBin() );
 		filter->setColumns( m_rootOptionsWidget->columns() );
 
 		return filter;
 	}
 	case AbstractFileFilter::NgspiceRawAscii: {
-			auto filter = new NgspiceRawAsciiFilter();
+			auto* filter = new NgspiceRawAsciiFilter();
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 			return filter;
 		}
 	case AbstractFileFilter::NgspiceRawBinary: {
-			auto filter = new NgspiceRawBinaryFilter();
+			auto* filter = new NgspiceRawBinaryFilter();
 			filter->setStartRow( ui.sbStartRow->value() );
 			filter->setEndRow( ui.sbEndRow->value() );
 			return filter;
 		}
 	}
 
 	return nullptr;
 }
 
 /*!
 	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())	//cancel was clicked in the file-dialog
 		return;
 
 	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(";"));
 }
 
 /*!
 	hides the MQTT related items of the widget
 */
 void ImportFileWidget::setMQTTVisible(bool visible) {
 	ui.lConnections->setVisible(visible);
 	ui.cbConnection->setVisible(visible);
 	ui.bManageConnections->setVisible(visible);
 	ui.cbQos->setVisible(visible);
 	ui.lQos->setVisible(visible);
 
 	//topics
 	if (ui.cbConnection->currentIndex() != -1 && visible) {
 		ui.lTopics->setVisible(true);
 		ui.gbManageSubscriptions->setVisible(true);
 	} else {
 		ui.lTopics->setVisible(false);
 		ui.gbManageSubscriptions->setVisible(false);
 	}
 
 	//will message
 	ui.lWillMessage->setVisible(visible);
 	ui.bWillMessage->setVisible(visible);
 }
 
 #ifdef HAVE_MQTT
 /*!
  * returns \c true if there is a valid connection to an MQTT broker and the user has subscribed to at least 1 topic,
  * returns \c false otherwise.
  */
 bool ImportFileWidget::isMqttValid(){
 	bool connected = (m_client->state() == QMqttClient::ClientState::Connected);
 	bool subscribed = (ui.twSubscriptions->topLevelItemCount() > 0);
 	bool fileTypeOk = false;
 	if (this->currentFileType() == AbstractFileFilter::FileType::Ascii)
 		fileTypeOk = true;
 	return connected && subscribed && fileTypeOk;
 }
 
 /*!
  *\brief Checks if a topic contains another one
  *
  * \param superior the name of a topic
  * \param inferior the name of a topic
  * \return	true if superior is equal to or contains(if superior contains wildcards) inferior,
  *			false otherwise
  */
 bool ImportFileWidget::checkTopicContains(const QString& superior, const QString& inferior) {
 	if (superior == inferior)
 		return true;
 
 	if (!superior.contains('/'))
 		return false;
 
 	const QStringList& superiorList = superior.split('/', QString::SkipEmptyParts);
 	const QStringList& inferiorList = inferior.split('/', QString::SkipEmptyParts);
 
 	//a longer topic can't contain a shorter one
 	if (superiorList.size() > inferiorList.size())
 		return false;
 
 	bool ok = true;
 	for (int i = 0; i < superiorList.size(); ++i) {
 		if (superiorList.at(i) != inferiorList.at(i)) {
 			if ((superiorList.at(i) != '+') &&
 					!(superiorList.at(i) == "#" && i == superiorList.size() - 1)) {
 				//if the two topics differ, and the superior's current level isn't + or #(which can be only in the last position)
 				//then superior can't contain inferior
 				ok = false;
 				break;
 			} else if (i == superiorList.size() - 1 && (superiorList.at(i) == '+' && inferiorList.at(i) == "#") ) {
 				//if the two topics differ at the last level
 				//and the superior's current level is + while the inferior's is #(which can be only in the last position)
 				//then superior can't contain inferior
 				ok = false;
 				break;
 			}
 		}
 	}
 	return ok;
 }
 
 /*!
  *\brief Returns the '+' wildcard containing topic name, which includes the given topic names
  *
  * \param first the name of a topic
  * \param second the name of a topic
  * \return The name of the common topic, if it exists, otherwise ""
  */
 QString ImportFileWidget::checkCommonLevel(const QString& first, const QString& second) {
 	const QStringList& firstList = first.split('/', QString::SkipEmptyParts);
 	if (firstList.isEmpty())
 		return QString();
 
 	const QStringList& secondtList = second.split('/', QString::SkipEmptyParts);
 	QString commonTopic = "";
 
 	//the two topics have to be the same size and can't be identic
 	if (firstList.size() == secondtList.size() && (first != second))	{
 
 		//the index where they differ
 		int differIndex = -1;
 		for (int i = 0; i < firstList.size(); ++i) {
 			if (firstList.at(i) != secondtList.at(i)) {
 				differIndex = i;
 				break;
 			}
 		}
 
 		//they can differ at only one level
 		bool differ = false;
 		if (differIndex > 0) {
 			for (int j = differIndex + 1; j < firstList.size(); ++j) {
 				if (firstList.at(j) != secondtList.at(j)) {
 					differ = true;
 					break;
 				}
 			}
 		} else
 			differ = true;
 
 		if (!differ) {
 			for (int i = 0; i < firstList.size(); ++i) {
 				if (i != differIndex) {
 					commonTopic.append(firstList.at(i));
 				} else {
 					//we put '+' wildcard at the level where they differ
 					commonTopic.append('+');
 				}
 
 				if (i != firstList.size() - 1)
 					commonTopic.append('/');
 			}
 		}
 	}
 
 	qDebug() << "Common topic for " << first << " and " << second << " is: " << commonTopic;
 	return commonTopic;
 }
 
 /*!
  *\brief Returns the index of level where the two topic names differ, if there is a common topic for them
  *
  * \param first the name of a topic
  * \param second the name of a topic
  * \return The index of the unequal level, if there is a common topic, otherwise -1
  */
 int ImportFileWidget::commonLevelIndex(const QString& first, const QString& second) {
 	QStringList firstList = first.split('/', QString::SkipEmptyParts);
 	QStringList secondtList = second.split('/', QString::SkipEmptyParts);
 	QString commonTopic = "";
 	int differIndex = -1;
 
 	if (!firstList.isEmpty()) {
 		//the two topics have to be the same size and can't be identic
 		if (firstList.size() == secondtList.size() && (first != second))	{
 
 			//the index where they differ
 			for (int i = 0; i < firstList.size(); ++i) {
 				if (firstList.at(i) != secondtList.at(i)) {
 					differIndex = i;
 					break;
 				}
 			}
 
 			//they can differ at only one level
 			bool differ = false;
 			if (differIndex > 0) {
 				for (int j = differIndex + 1; j < firstList.size(); ++j) {
 					if (firstList.at(j) != secondtList.at(j)) {
 						differ = true;
 						break;
 					}
 				}
 			}
 			else
 				differ = true;
 
 			if (!differ) {
 				for (int i = 0; i < firstList.size(); ++i) {
 					if (i != differIndex)
 						commonTopic.append(firstList.at(i));
 					else
 						commonTopic.append('+');
 
 					if (i != firstList.size() - 1)
 						commonTopic.append('/');
 				}
 			}
 		}
 	}
 
 	//if there is a common topic we return the differIndex
 	if (!commonTopic.isEmpty())
 		return differIndex;
 	else
 		return -1;
 }
 
 /*!
  *\brief Unsubscribes from the given topic, and removes any data connected to it
  *
  * \param topicName the name of a topic we want to unsubscribe from
  */
 void ImportFileWidget::unsubscribeFromTopic(const QString& topicName) {
 	if (topicName.isEmpty())
 		return;
 
 	QMqttTopicFilter filter{topicName};
 	m_client->unsubscribe(filter);
 
 	for (int i = 0; i< m_mqttSubscriptions.count(); ++i)
 		if (m_mqttSubscriptions[i]->topic().filter() == topicName) {
 			m_mqttSubscriptions.remove(i);
 			break;
 		}
 
 	m_mqttReadyForPreview = false;
 
 	QMapIterator<QMqttTopicName, bool> i(m_messageArrived);
 	while(i.hasNext()) {
 		i.next();
 		if (checkTopicContains(topicName, i.key().name())) {
 			m_messageArrived.remove(i.key());
 		}
 	}
 
 	QMapIterator<QMqttTopicName, QMqttMessage> j(m_lastMessage);
 	while(j.hasNext()) {
 		j.next();
 		if (checkTopicContains(topicName, j.key().name())) {
 			m_lastMessage.remove(j.key());
 		}
 	}
 
 	for (int row = 0; row < ui.twSubscriptions->topLevelItemCount(); row++)  {
 		if (ui.twSubscriptions->topLevelItem(row)->text(0) == topicName) {
 			ui.twSubscriptions->topLevelItem(row)->takeChildren();
 			ui.twSubscriptions->takeTopLevelItem(row);
 		}
 	}
 
 	for (int i = 0; i < m_subscribedTopicNames.size(); ++i) {
 		if (checkTopicContains(topicName, m_subscribedTopicNames[i])) {
 			m_subscribedTopicNames.remove(i);
 			i--;
 		}
 	}
 
 	if(m_willSettings.willTopic == topicName) {
 		QVector<QTreeWidgetItem*> children;
 		if(ui.twSubscriptions->topLevelItemCount() > 0) {
 			findSubscriptionLeafChildren(children, ui.twSubscriptions->topLevelItem(0));
 			m_willSettings.willTopic = children[0]->text(0);
 		} else
 			m_willSettings.willTopic = "";
 	}
 
 	//signals that there was a change among the subscribed topics
 	emit subscriptionsChanged();
 	refreshPreview();
 }
 
 /*!
  *\brief Adds to a # wildcard containing topic, every topic present in twTopics that the former topic contains
  *
  * \param topic pointer to the TreeWidgetItem which was selected before subscribing
  * \param subscription pointer to the TreeWidgetItem which represents the new subscirption,
  *		  we add all of the children to this item
  */
 void ImportFileWidget::addSubscriptionChildren(QTreeWidgetItem * topic, QTreeWidgetItem * subscription) {
 	//if the topic doesn't have any children we don't do anything
 	if (topic->childCount() <= 0)
 		return;
 
 	for (int i = 0; i < topic->childCount(); ++i) {
 		QTreeWidgetItem* temp = topic->child(i);
 		QString name;
 		//if it has children, then we add it as a # wildcrad containing topic
 		if (topic->child(i)->childCount() > 0) {
 			name.append(temp->text(0) + "/#");
 			while(temp->parent() != nullptr) {
 				temp = temp->parent();
 				name.prepend(temp->text(0) + '/');
 			}
 		}
 
 		//if not then we simply add the topic itself
 		else {
 			name.append(temp->text(0));
 			while(temp->parent() != nullptr) {
 				temp = temp->parent();
 				name.prepend(temp->text(0) + '/');
 			}
 		}
 
 		QStringList nameList;
 		nameList.append(name);
 		QTreeWidgetItem* childItem = new QTreeWidgetItem(nameList);
 		subscription->addChild(childItem);
 		//we use the function recursively on the given item
 		addSubscriptionChildren(topic->child(i), childItem);
 	}
 }
 
 /*!
  *\brief Fills the children vector, with the root item's (twSubscriptions) leaf children (meaning no wildcard containing topics)
  *
  * \param children vector of TreeWidgetItem pointers
  * \param root pointer to a TreeWidgetItem of twSubscriptions
  */
 void ImportFileWidget::findSubscriptionLeafChildren(QVector<QTreeWidgetItem*>& children, QTreeWidgetItem* root) {
 	if (root->childCount() == 0)
 		children.push_back(root);
 	else
 		for (int i = 0; i < root->childCount(); ++i)
 			findSubscriptionLeafChildren(children, root->child(i));
 }
 
 /*!
  *\brief Returns the amount of topics that the '+' wildcard will replace in the level position
  *
  * \param levelIdx the level currently being investigated
  * \param level the level where the new + wildcard will be placed
  * \param commonList the topic name split into levels
  * \param currentItem pointer to a TreeWidgetItem which represents the parent of the level
  *		  represented by levelIdx
  * \return returns the childCount, or -1 if some topics already represented by + wildcard have different
  *		   amount of children
  */
 int ImportFileWidget::checkCommonChildCount(int levelIdx, int level, QStringList& commonList, QTreeWidgetItem* currentItem) {
 	//we recursively check the number of children, until we get to level-1
 	if (levelIdx < level - 1) {
 		if (commonList[levelIdx] != '+') {
 			for (int j = 0; j < currentItem->childCount(); ++j) {
 				if (currentItem->child(j)->text(0) == commonList[levelIdx]) {
 					//if the level isn't represented by + wildcard we simply return the amount of children of the corresponding item, recursively
 					return checkCommonChildCount(levelIdx + 1, level, commonList, currentItem->child(j));
 				}
 			}
 		} else {
 			int childCount = -1;
 			bool ok = true;
 
 			//otherwise we check if every + wildcard represented topic has the same number of children, recursively
 			for (int j = 0; j < currentItem->childCount(); ++j) {
 				int temp = checkCommonChildCount(levelIdx + 1, level, commonList, currentItem->child(j));
 				if ((j > 0) && (temp != childCount)) {
 					ok = false;
 					break;
 				}
 				childCount = temp;
 			}
 
 			//if yes we return this number, otherwise -1
 			if (ok)
 				return childCount;
 			else
 				return -1;
 		}
 	} else if (levelIdx == level - 1) {
 		if (commonList[levelIdx] != '+') {
 			for (int j = 0; j < currentItem->childCount(); ++j) {
 				if (currentItem->child(j)->text(0) == commonList[levelIdx]) {
 					//if the level isn't represented by + wildcard we simply return the amount of children of the corresponding item
 					return currentItem->child(j)->childCount();
 				}
 			}
 		} else {
 			int childCount = -1;
 			bool ok = true;
 
 			//otherwise we check if every + wildcard represented topic has the same number of children
 			for (int j = 0; j < currentItem->childCount(); ++j) {
 				if ((j > 0) && (currentItem->child(j)->childCount() != childCount)) {
 					ok = false;
 					break;
 				}
 				childCount = currentItem->child(j)->childCount();
 			}
 
 			//if yes we return this number, otherwise -1
 			if (ok)
 				return childCount;
 			else
 				return -1;
 		}
 
 	} else if (level == 1 && levelIdx == 1)
 		return currentItem->childCount();
 
 	return -1;
 }
 
 /*!
  *\brief We search in twSubscriptions for topics that can be represented using + wildcards, then merge them.
  *		 We do this until there are no topics to merge
  */
 void ImportFileWidget::manageCommonLevelSubscriptions() {
 	bool foundEqual = false;
 
 	do{
 		foundEqual = false;
 		QMap<QString, QVector<QString>> equalTopicsMap;
 		QVector<QString> equalTopics;
 
 		//compare the subscriptions present in the TreeWidget
 		for (int i = 0; i < ui.twSubscriptions->topLevelItemCount() - 1; ++i) {
 			for (int j = i + 1; j < ui.twSubscriptions->topLevelItemCount(); ++j) {
 				QString commonTopic = checkCommonLevel(ui.twSubscriptions->topLevelItem(i)->text(0), ui.twSubscriptions->topLevelItem(j)->text(0));
 
 				//if there is a common topic for the 2 compared topics, we add them to the map (using the common topic as key)
 				if (!commonTopic.isEmpty()) {
 					if (!equalTopicsMap[commonTopic].contains(ui.twSubscriptions->topLevelItem(i)->text(0))) {
 						equalTopicsMap[commonTopic].push_back(ui.twSubscriptions->topLevelItem(i)->text(0));
 					}
 
 					if (!equalTopicsMap[commonTopic].contains(ui.twSubscriptions->topLevelItem(j)->text(0))) {
 						equalTopicsMap[commonTopic].push_back(ui.twSubscriptions->topLevelItem(j)->text(0));
 					}
 				}
 			}
 		}
 
 		if (!equalTopicsMap.isEmpty()) {
 			qDebug()<<"Manage common topics";
 
 			QVector<QString> commonTopics;
 			QMapIterator<QString, QVector<QString>> topics(equalTopicsMap);
 
 			//check for every map entry, if the found topics can be merged or not
 			while(topics.hasNext()) {
 				topics.next();
 
 				int level = commonLevelIndex(topics.value().last(), topics.value().first());
 				QStringList commonList = topics.value().first().split('/', QString::SkipEmptyParts);
 				QTreeWidgetItem* currentItem = nullptr;
 				//search the corresponding item to the common topics first level(root)
 				for (int i = 0; i < ui.twTopics->topLevelItemCount(); ++i) {
 					if (ui.twTopics->topLevelItem(i)->text(0) == commonList.first()) {
 						currentItem = ui.twTopics->topLevelItem(i);
 						break;
 					}
 				}
 
 				//calculate the number of topics the new + wildcard could replace
 				int childCount = checkCommonChildCount(1, level, commonList, currentItem);
 				if (childCount > 0) {
 					//if the number of topics found and the calculated number of topics is equal, the topics can be merged
 					if (topics.value().size() == childCount) {
 						qDebug() << "Found common topic to manage: " << topics.key();
 						foundEqual = true;
 						commonTopics.push_back(topics.key());
 					}
 				}
 			}
 
 			if (foundEqual) {
 				//if there are more common topics, the topics of which can be merged, we choose the one which has the lowest level new '+' wildcard
 				int lowestLevel = INT_MAX;
 				int topicIdx = -1;
 				for (int i = 0; i < commonTopics.size(); ++i) {
 					int level = commonLevelIndex(equalTopicsMap[commonTopics[i]].first(), commonTopics[i]);
 					if (level < lowestLevel) {
 						topicIdx = i;
 						lowestLevel = level;
 					}
 				}
 				qDebug() << "Manage: " << commonTopics[topicIdx];
 				equalTopics.append(equalTopicsMap[commonTopics[topicIdx]]);
 
 				//Add the common topic ("merging")
 				QString commonTopic;
 				commonTopic = checkCommonLevel(equalTopics.first(), equalTopics.last());
 				QStringList nameList;
 				nameList.append(commonTopic);
 				QTreeWidgetItem* newTopic = new QTreeWidgetItem(nameList);
 				ui.twSubscriptions->addTopLevelItem(newTopic);
 				QMqttTopicFilter filter {commonTopic};
 				QMqttSubscription *temp_subscription = m_client->subscribe(filter, static_cast<quint8> (ui.cbQos->currentText().toUInt()) );
 
 				if (temp_subscription) {
 					m_mqttSubscriptions.push_back(temp_subscription);
 					connect(temp_subscription, &QMqttSubscription::messageReceived, this, &ImportFileWidget::mqttSubscriptionMessageReceived);
 					emit subscriptionsChanged();
 				}
 
 				//remove the "merged" topics
 				for (int i = 0; i < equalTopics.size(); ++i) {
 					for (int j = 0; j < ui.twSubscriptions->topLevelItemCount(); ++j){
 						if (ui.twSubscriptions->topLevelItem(j)->text(0) == equalTopics[i]) {
 							newTopic->addChild(ui.twSubscriptions->takeTopLevelItem(j));
 							unsubscribeFromTopic(equalTopics[i]);
 							break;
 						}
 					}
 				}
 
 				//remove any subscription that the new subscription contains
 				for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 					if (checkTopicContains(commonTopic, ui.twSubscriptions->topLevelItem(i)->text(0)) &&
 							commonTopic != ui.twSubscriptions->topLevelItem(i)->text(0) ) {
 						unsubscribeFromTopic(ui.twSubscriptions->topLevelItem(i)->text(0));
 						i--;
 					}
 				}
 			}
 		}
 	} while(foundEqual);
 }
 
 /*!
  *\brief Fills twSubscriptions with the subscriptions made by the client
  */
 void ImportFileWidget::updateSubscriptionTree() {
 	DEBUG("ImportFileWidget::updateSubscriptionTree()");
 	ui.twSubscriptions->clear();
 
 	for (int i = 0; i < m_mqttSubscriptions.size(); ++i) {
 		QStringList name;
 		name.append(m_mqttSubscriptions[i]->topic().filter());
 
 		bool found = false;
 		for (int j = 0; j < ui.twSubscriptions->topLevelItemCount(); ++j) {
 			if (ui.twSubscriptions->topLevelItem(j)->text(0) == m_mqttSubscriptions[i]->topic().filter()) {
 				found = true;
 				break;
 			}
 		}
 
 		if (!found) {
 			//Add the subscription to the tree widget
 			QTreeWidgetItem* newItem = new QTreeWidgetItem(name);
 			ui.twSubscriptions->addTopLevelItem(newItem);
 			name.clear();
 			name = m_mqttSubscriptions[i]->topic().filter().split('/', QString::SkipEmptyParts);
 
 			//find the corresponding "root" item in twTopics
 			QTreeWidgetItem* topic = nullptr;
 			for (int j = 0; j < ui.twTopics->topLevelItemCount(); ++j) {
 				if (ui.twTopics->topLevelItem(j)->text(0) == name[0]) {
 					topic = ui.twTopics->topLevelItem(j);
 					break;
 				}
 			}
 
 			//restore the children of the subscription
 			if (topic != nullptr && topic->childCount() > 0) {
 				restoreSubscriptionChildren(topic, newItem, name, 1);
 			}
 		}
 	}
 	m_searching = false;
 }
 
 /*!
  *\brief Restores the children of a top level item in twSubscriptions if it contains wildcards
  *
  * \param topic pointer to a top level item in twTopics which represents the root of the subscription topic
  * \param subscription pointer to a top level item in twSubscriptions, this is the item whose children will be restored
  * \param list QStringList containing the levels of the subscription topic
  * \param level the level's number which is being investigated
  */
 void ImportFileWidget::restoreSubscriptionChildren(QTreeWidgetItem * topic, QTreeWidgetItem * subscription, const QStringList& list, int level) {
 	DEBUG("ImportFileWidget::restoreSubscriptionChildren");
 	if (list[level] != '+' && list[level] != "#" && level < list.size() - 1) {
 		for (int i = 0; i < topic->childCount(); ++i) {
 			//if the current level isn't + or # wildcard we recursively continue with the next level
 			if (topic->child(i)->text(0) == list[level]) {
 				restoreSubscriptionChildren(topic->child(i), subscription, list, level + 1);
 				break;
 			}
 		}
 	} else if (list[level] == '+') {
 		for (int i = 0; i < topic->childCount(); ++i) {
 			//determine the name of the topic, contained by the subscription
 			QString name;
 			name.append(topic->child(i)->text(0));
 			for (int j = level + 1; j < list.size(); ++j) {
 				name.append('/' + list[j]);
 			}
 			QTreeWidgetItem* temp = topic->child(i);
 			while(temp->parent() != nullptr) {
 				temp = temp->parent();
 				name.prepend(temp->text(0) + '/');
 			}
 
 			//Add the topic as child of the subscription
 			QStringList nameList;
 			nameList.append(name);
 			QTreeWidgetItem* newItem = new QTreeWidgetItem(nameList);
 			subscription->addChild(newItem);
 			//Continue adding children recursively to the new item
 			restoreSubscriptionChildren(topic->child(i), newItem, list, level + 1);
 		}
 	} else if (list[level] == "#") {
 		//add the children of the # wildcard containing subscription
 		addSubscriptionChildren(topic, subscription);
 	}
 }
 
 /*!
  *\brief Updates the completer for leSubscriptions
  */
 void ImportFileWidget::updateSubscriptionCompleter() {
 	QStringList subscriptionList;
 	for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i)
 		subscriptionList.append(ui.twSubscriptions->topLevelItem(i)->text(0));
 
 	if (!subscriptionList.isEmpty()) {
 		m_subscriptionCompleter = new QCompleter(subscriptionList, this);
 		m_subscriptionCompleter->setCompletionMode(QCompleter::PopupCompletion);
 		m_subscriptionCompleter->setCaseSensitivity(Qt::CaseSensitive);
 		ui.leSubscriptions->setCompleter(m_subscriptionCompleter);
 	} else
 		ui.leSubscriptions->setCompleter(nullptr);
 }
 #endif
 
 /************** SLOTS **************************************************************/
 
 QString absolutePath(const QString& fileName)
 {
 #ifndef HAVE_WINDOWS
 	// make absolute path // FIXME
 	if (!fileName.isEmpty() && fileName.at(0) != QDir::separator())
 		return QDir::homePath() + QDir::separator() + fileName;
 #endif
 	return fileName;
 }
 
 /*!
 	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) {
 	const QString fileName = absolutePath(name);
 
 	bool fileExists = QFile::exists(fileName);
 	if (fileExists)
 		ui.leFileName->setStyleSheet("");
 	else
 		ui.leFileName->setStyleSheet("QLineEdit{background:red;}");
 
 	ui.gbOptions->setEnabled(fileExists);
 	ui.bManageFilters->setEnabled(fileExists);
 	ui.cbFilter->setEnabled(fileExists);
 	ui.cbFileType->setEnabled(fileExists);
 	ui.bFileInfo->setEnabled(fileExists);
 	ui.gbUpdateOptions->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();
 		//TODO:
 // 		m_hdf5OptionsWidget->clear();
 // 		m_netcdfOptionsWidget->clear();
 // 		m_fitsOptionsWidget->clear();
 // 		m_jsonOptionsWidget->clearModel();
 // 		m_rootOptionsWidget->clear();
 
 		emit fileNameChanged();
 		return;
 	}
 
 	if (currentSourceType() == LiveDataSource::FileOrPipe) {
 		const AbstractFileFilter::FileType fileType = AbstractFileFilter::fileType(fileName);
 		for (int i = 0; i < ui.cbFileType->count(); ++i) {
 			AbstractFileFilter::FileType itemFileType = static_cast<AbstractFileFilter::FileType>(ui.cbFileType->itemData(i).toInt());
 			if (itemFileType == fileType) {
 				ui.cbFileType->setCurrentIndex(i);
 				break;
 			}
 		}
 		//TODO: updateContent(fileName, fileType);
 	}
 
 	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 index) {
 	Q_UNUSED(index);
 	AbstractFileFilter::FileType fileType = currentFileType();//(AbstractFileFilter::FileType)ui.cbFileType->itemData(index).toInt();
 	DEBUG("ImportFileWidget::fileTypeChanged " << ENUM_TO_STRING(AbstractFileFilter, FileType, fileType));
 	initOptionsWidget(fileType);
 
 	//default
 	ui.lFilter->show();
 	ui.cbFilter->show();
 
 	//different file types show different number of tabs in ui.tabWidget.
 	//when switching from the previous file type we re-set the tab widget to its original state
 	//and remove/add the required tabs further below
 	for (int i = 0; i<ui.tabWidget->count(); ++i)
 		ui.tabWidget->count();
 
 	ui.tabWidget->addTab(ui.tabDataFormat, i18n("Data format"));
 	ui.tabWidget->addTab(ui.tabDataPreview, i18n("Preview"));
 	ui.tabWidget->addTab(ui.tabDataPortion, i18n("Data portion to read"));
 
 	ui.lPreviewLines->show();
 	ui.sbPreviewLines->show();
 	ui.lStartColumn->show();
 	ui.sbStartColumn->show();
 	ui.lEndColumn->show();
 	ui.sbEndColumn->show();
 
 	showJsonModel(false);
 
 	switch (fileType) {
 	case AbstractFileFilter::Ascii:
 		break;
 	case AbstractFileFilter::Binary:
 		ui.lStartColumn->hide();
 		ui.sbStartColumn->hide();
 		ui.lEndColumn->hide();
 		ui.sbEndColumn->hide();
 		break;
 	case AbstractFileFilter::ROOT:
 		ui.tabWidget->removeTab(1);
 		// falls through
 	case AbstractFileFilter::HDF5:
 	case AbstractFileFilter::NETCDF:
 	case AbstractFileFilter::FITS:
 		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 AbstractFileFilter::Image:
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		ui.lPreviewLines->hide();
 		ui.sbPreviewLines->hide();
 		break;
 	case AbstractFileFilter::NgspiceRawAscii:
 	case AbstractFileFilter::NgspiceRawBinary:
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		ui.lStartColumn->hide();
 		ui.sbStartColumn->hide();
 		ui.lEndColumn->hide();
 		ui.sbEndColumn->hide();
 		ui.tabWidget->removeTab(0);
 		ui.tabWidget->setCurrentIndex(0);
 		break;
 	case AbstractFileFilter::JSON:
 		ui.lFilter->hide();
 		ui.cbFilter->hide();
 		showJsonModel(true);
 		break;
 	default:
 		DEBUG("unknown file type");
 	}
 
 	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);
 
 	if (currentSourceType() == LiveDataSource::FileOrPipe) {
 		const QString fileName = absolutePath(ui.leFileName->text());
 
 		if (QFile::exists(fileName))
 			updateContent(fileName, static_cast<AbstractFileFilter::FileType>(fileType));
 	}
 
 	//for file types other than ASCII and binary we support re-reading the whole file only
 	//select "read whole file" and deactivate the combobox
 	if (m_liveDataSource && (fileType != AbstractFileFilter::Ascii && fileType != AbstractFileFilter::Binary)) {
 		ui.cbReadingType->setCurrentIndex(3);
 		ui.cbReadingType->setEnabled(false);
 	} else
 		ui.cbReadingType->setEnabled(true);
 
 	refreshPreview();
 }
 
 // file type specific option widgets
 void ImportFileWidget::initOptionsWidget(AbstractFileFilter::FileType fileType) {
 	DEBUG("ImportFileWidget::initOptionsWidget for " << ENUM_TO_STRING(AbstractFileFilter, FileType, fileType));
 	switch(fileType) {
 	case AbstractFileFilter::Ascii:
 		if (!m_asciiOptionsWidget) {
 			QWidget* asciiw = new QWidget();
 			m_asciiOptionsWidget = std::unique_ptr<AsciiOptionsWidget>(new AsciiOptionsWidget(asciiw));
 			m_asciiOptionsWidget->loadSettings();
 			ui.swOptions->addWidget(asciiw);
 		}
 		ui.swOptions->setCurrentWidget(m_asciiOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::Binary:
 		if (!m_binaryOptionsWidget) {
 			QWidget* binaryw = new QWidget();
 			m_binaryOptionsWidget = std::unique_ptr<BinaryOptionsWidget>(new BinaryOptionsWidget(binaryw));
 			ui.swOptions->addWidget(binaryw);
 			m_binaryOptionsWidget->loadSettings();
 		}
 		ui.swOptions->setCurrentWidget(m_binaryOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::Image:
 		if (!m_imageOptionsWidget) {
 			QWidget* imagew = new QWidget();
 			m_imageOptionsWidget = std::unique_ptr<ImageOptionsWidget>(new ImageOptionsWidget(imagew));
 			ui.swOptions->addWidget(imagew);
 			m_imageOptionsWidget->loadSettings();
 		}
 		ui.swOptions->setCurrentWidget(m_imageOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::HDF5:
 		if (!m_hdf5OptionsWidget) {
 			QWidget* hdf5w = new QWidget();
 			m_hdf5OptionsWidget = std::unique_ptr<HDF5OptionsWidget>(new HDF5OptionsWidget(hdf5w, this));
 			ui.swOptions->addWidget(hdf5w);
 		} else
 			m_hdf5OptionsWidget->clear();
 		ui.swOptions->setCurrentWidget(m_hdf5OptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::NETCDF:
 		if (!m_netcdfOptionsWidget) {
 			QWidget* netcdfw = new QWidget();
 			m_netcdfOptionsWidget = std::unique_ptr<NetCDFOptionsWidget>(new NetCDFOptionsWidget(netcdfw, this));
 			ui.swOptions->insertWidget(AbstractFileFilter::NETCDF, netcdfw);
 		} else
 			m_netcdfOptionsWidget->clear();
 		ui.swOptions->setCurrentWidget(m_netcdfOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::FITS:
 		if (!m_fitsOptionsWidget) {
 			QWidget* fitsw = new QWidget();
 			m_fitsOptionsWidget = std::unique_ptr<FITSOptionsWidget>(new FITSOptionsWidget(fitsw, this));
 			ui.swOptions->addWidget(fitsw);
 		}
 		ui.swOptions->setCurrentWidget(m_fitsOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::JSON:
 		if (!m_jsonOptionsWidget) {
 			QWidget* jsonw = new QWidget();
 			m_jsonOptionsWidget = std::unique_ptr<JsonOptionsWidget>(new JsonOptionsWidget(jsonw, this));
 			ui.tvJson->setModel(m_jsonOptionsWidget->model());
 			ui.swOptions->addWidget(jsonw);
 			m_jsonOptionsWidget->loadSettings();
 		}
 		ui.swOptions->setCurrentWidget(m_jsonOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::ROOT:
 		if (!m_rootOptionsWidget) {
 			QWidget* rootw = new QWidget();
 			m_rootOptionsWidget = std::unique_ptr<ROOTOptionsWidget>(new ROOTOptionsWidget(rootw, this));
 			ui.swOptions->addWidget(rootw);
 		} else
 			m_rootOptionsWidget->clear();
 		ui.swOptions->setCurrentWidget(m_rootOptionsWidget->parentWidget());
 		break;
 	case AbstractFileFilter::NgspiceRawAscii:
 	case AbstractFileFilter::NgspiceRawBinary:
 		break;
 	}
 }
 
 const QStringList ImportFileWidget::selectedHDF5Names() const {
 	return m_hdf5OptionsWidget->selectedHDF5Names();
 }
 
 const QStringList ImportFileWidget::selectedNetCDFNames() const {
 	return m_netcdfOptionsWidget->selectedNetCDFNames();
 }
 
 const QStringList ImportFileWidget::selectedFITSExtensions() const {
 	return m_fitsOptionsWidget->selectedFITSExtensions();
 }
 
 const QStringList ImportFileWidget::selectedROOTNames() const {
 	return m_rootOptionsWidget->selectedROOTNames();
 }
 
 /*!
 	shows the dialog with the information about the file(s) to be imported.
 */
 void ImportFileWidget::fileInfoDialog() {
 	QStringList files = ui.leFileName->text().split(';');
-	auto dlg = new FileInfoDialog(this);
+	auto* 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
 	AbstractFileFilter::FileType fileType = currentFileType();
 	if (fileType != AbstractFileFilter::Ascii && fileType != AbstractFileFilter::Binary) {
 		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() {
 	if (m_suppressRefresh)
 		return;
 
 	WAIT_CURSOR;
 
 	QString fileName = absolutePath(ui.leFileName->text());
 	AbstractFileFilter::FileType fileType = currentFileType();
 	LiveDataSource::SourceType sourceType = currentSourceType();
 	int lines = ui.sbPreviewLines->value();
 
 	if (sourceType == LiveDataSource::SourceType::FileOrPipe)
 		DEBUG("refreshPreview(): file name = " << fileName.toStdString());
 
 	// generic table widget
 	if (fileType == AbstractFileFilter::Ascii || fileType == AbstractFileFilter::Binary
 		|| fileType == AbstractFileFilter::JSON || fileType == AbstractFileFilter::NgspiceRawAscii
 		|| fileType == AbstractFileFilter::NgspiceRawBinary)
 		m_twPreview->show();
 	else
 		m_twPreview->hide();
 
 	bool ok = true;
 	QTableWidget* tmpTableWidget = m_twPreview;
 	QVector<QStringList> importedStrings;
 	QStringList vectorNameList;
 	QVector<AbstractColumn::ColumnMode> columnModes;
 	DEBUG("Data File Type: " << ENUM_TO_STRING(AbstractFileFilter, FileType, fileType));
 	switch (fileType) {
 	case AbstractFileFilter::Ascii: {
 		ui.tePreview->clear();
 
-		auto filter = static_cast<AsciiFilter*>(this->currentFileFilter());
+		auto* filter = static_cast<AsciiFilter*>(this->currentFileFilter());
 
 		DEBUG("Data Source Type: " << ENUM_TO_STRING(LiveDataSource, SourceType, sourceType));
 		switch (sourceType) {
 		case LiveDataSource::SourceType::FileOrPipe: {
 			importedStrings = filter->preview(fileName, lines);
 			break;
 		}
 		case LiveDataSource::SourceType::LocalSocket: {
 			QLocalSocket lsocket{this};
 			DEBUG("Local socket: CONNECT PREVIEW");
 			lsocket.connectToServer(fileName, QLocalSocket::ReadOnly);
 			if (lsocket.waitForConnected()) {
 				DEBUG("connected to local socket " << fileName.toStdString());
 				if (lsocket.waitForReadyRead())
 					importedStrings = filter->preview(lsocket);
 				DEBUG("Local socket: DISCONNECT PREVIEW");
 				lsocket.disconnectFromServer();
 				// read-only socket is disconnected immediately (no waitForDisconnected())
 			} else {
 				DEBUG("failed connect to local socket " << fileName.toStdString() << " - " << lsocket.errorString().toStdString());
 			}
 
 			break;
 		}
 		case LiveDataSource::SourceType::NetworkTcpSocket: {
 			QTcpSocket tcpSocket{this};
 			tcpSocket.connectToHost(host(), port().toInt(), QTcpSocket::ReadOnly);
 			if (tcpSocket.waitForConnected()) {
 				DEBUG("connected to TCP socket");
 				if ( tcpSocket.waitForReadyRead() )
 					importedStrings = filter->preview(tcpSocket);
 
 				tcpSocket.disconnectFromHost();
 			} else {
 				DEBUG("failed to connect to TCP socket " << " - " << tcpSocket.errorString().toStdString());
 			}
 
 			break;
 		}
 		case LiveDataSource::SourceType::NetworkUdpSocket: {
 			QUdpSocket udpSocket{this};
 			DEBUG("UDP Socket: CONNECT PREVIEW, state = " << udpSocket.state());
 			udpSocket.bind(QHostAddress(host()), port().toInt());
 			udpSocket.connectToHost(host(), 0, QUdpSocket::ReadOnly);
 			if (udpSocket.waitForConnected()) {
 				DEBUG("	connected to UDP socket " << host().toStdString() << ':' << port().toInt());
 				if (!udpSocket.waitForReadyRead(2000) )
 					DEBUG("	ERROR: not ready for read after 2 sec");
 				if (udpSocket.hasPendingDatagrams()) {
 					DEBUG("	has pending data");
 				} else {
 					DEBUG("	has no pending data");
 				}
 				importedStrings = filter->preview(udpSocket);
 
 				DEBUG("UDP Socket: DISCONNECT PREVIEW, state = " << udpSocket.state());
 				udpSocket.disconnectFromHost();
 			} else {
 				DEBUG("failed to connect to UDP socket " << " - " << udpSocket.errorString().toStdString());
 			}
 
 			break;
 		}
 		case LiveDataSource::SourceType::SerialPort: {
 			QSerialPort sPort{this};
 			DEBUG("	Port: " << serialPort().toStdString() << ", Settings: " << baudRate() << ',' << sPort.dataBits()
 					<< ',' << sPort.parity() << ',' << sPort.stopBits());
 			sPort.setPortName(serialPort());
 			sPort.setBaudRate(baudRate());
 
 			if (sPort.open(QIODevice::ReadOnly)) {
 				if (sPort.waitForReadyRead(2000))
 					importedStrings = filter->preview(sPort);
 				else {
 					DEBUG("	ERROR: not ready for read after 2 sec");
 				}
 
 				sPort.close();
 			} else {
 				DEBUG("	ERROR: failed to open serial port. error: " << sPort.error());
 			}
 			break;
 		}
 		case LiveDataSource::SourceType::MQTT: {
 #ifdef HAVE_MQTT
 			qDebug()<<"Start MQTT preview, is it ready:"<<m_mqttReadyForPreview;
 			if (m_mqttReadyForPreview) {
 				filter->vectorNames().clear();
 				QMapIterator<QMqttTopicName, QMqttMessage> i(m_lastMessage);
 				while(i.hasNext()) {
 					i.next();
 					filter->MQTTPreview(importedStrings, QString(i.value().payload().data()), i.key().name() );
 					if (importedStrings.isEmpty())
 						break;
 				}
 
 				QMapIterator<QMqttTopicName, bool> j(m_messageArrived);
 				while(j.hasNext()) {
 					j.next();
 					m_messageArrived[j.key()] = false;
 				}
 				m_mqttReadyForPreview = false;
 			}
 #endif
 			break;
 		}
 		}
 
 		vectorNameList = filter->vectorNames();
 		columnModes = filter->columnModes();
 		break;
 	}
 	case AbstractFileFilter::Binary: {
 		ui.tePreview->clear();
-		auto filter = (BinaryFilter *)this->currentFileFilter();
+		auto* filter = (BinaryFilter*)this->currentFileFilter();
 		importedStrings = filter->preview(fileName, lines);
 		break;
 	}
 	case AbstractFileFilter::Image: {
 		ui.tePreview->clear();
 
 		QImage image(fileName);
 		QTextCursor cursor = ui.tePreview->textCursor();
 		cursor.insertImage(image);
 		RESET_CURSOR;
 		return;
 	}
 	case AbstractFileFilter::HDF5: {
-		auto filter = (HDF5Filter *)this->currentFileFilter();
+		auto* filter = (HDF5Filter*)this->currentFileFilter();
 		lines = m_hdf5OptionsWidget->lines();
 		importedStrings = filter->readCurrentDataSet(fileName, nullptr, ok, AbstractFileFilter::Replace, lines);
 		tmpTableWidget = m_hdf5OptionsWidget->previewWidget();
 		break;
 	}
 	case AbstractFileFilter::NETCDF: {
-		auto filter = (NetCDFFilter *)this->currentFileFilter();
+		auto* filter = (NetCDFFilter*)this->currentFileFilter();
 		lines = m_netcdfOptionsWidget->lines();
 		importedStrings = filter->readCurrentVar(fileName, nullptr, AbstractFileFilter::Replace, lines);
 		tmpTableWidget = m_netcdfOptionsWidget->previewWidget();
 		break;
 	}
 	case AbstractFileFilter::FITS: {
-		auto filter = (FITSFilter*)this->currentFileFilter();
+		auto* filter = (FITSFilter*)this->currentFileFilter();
 		lines = m_fitsOptionsWidget->lines();
 
 		// update file name (may be any file type)
 		m_fitsOptionsWidget->updateContent(filter, fileName);
 		QString extensionName = m_fitsOptionsWidget->extensionName(&ok);
 		if (!extensionName.isEmpty()) {
 			DEBUG("	extension name = " << extensionName.toStdString());
 			fileName = extensionName;
 		}
 		DEBUG("	file name = " << fileName.toStdString());
 
 		bool readFitsTableToMatrix;
 		importedStrings = filter->readChdu(fileName, &readFitsTableToMatrix, lines);
 		emit checkedFitsTableToMatrix(readFitsTableToMatrix);
 
 		tmpTableWidget = m_fitsOptionsWidget->previewWidget();
 		break;
 	}
 	case AbstractFileFilter::JSON: {
 		ui.tePreview->clear();
 		m_jsonOptionsWidget->loadDocument(fileName);
-		auto filter = (JsonFilter*)this->currentFileFilter();
+		auto* filter = (JsonFilter*)this->currentFileFilter();
 		m_jsonOptionsWidget->applyFilterSettings(filter, ui.tvJson->currentIndex());
 		importedStrings = filter->preview(fileName);
 
 		vectorNameList = filter->vectorNames();
 		columnModes = filter->columnModes();
 		break;
 	}
 	case AbstractFileFilter::ROOT: {
-		auto filter = (ROOTFilter *)this->currentFileFilter();
+		auto* filter = (ROOTFilter*)this->currentFileFilter();
 		lines = m_rootOptionsWidget->lines();
 		m_rootOptionsWidget->setNBins(filter->binsInCurrentHistogram(fileName));
 		importedStrings = filter->previewCurrentHistogram(
 					fileName,
 					m_rootOptionsWidget->startBin(),
 					qMin(m_rootOptionsWidget->startBin() + m_rootOptionsWidget->lines() - 1,
 						 m_rootOptionsWidget->endBin())
 					);
 		tmpTableWidget = m_rootOptionsWidget->previewWidget();
 		// the last vector element contains the column names
 		vectorNameList = importedStrings.last();
 		importedStrings.removeLast();
 		columnModes = QVector<AbstractColumn::ColumnMode>(vectorNameList.size(), AbstractColumn::Numeric);
 		break;
 	}
 	case AbstractFileFilter::NgspiceRawAscii: {
 		ui.tePreview->clear();
-		auto filter = (NgspiceRawAsciiFilter*)this->currentFileFilter();
+		auto* filter = (NgspiceRawAsciiFilter*)this->currentFileFilter();
 		importedStrings = filter->preview(fileName, lines);
 		vectorNameList = filter->vectorNames();
 		columnModes = filter->columnModes();
 		break;
 	}
 	case AbstractFileFilter::NgspiceRawBinary: {
 		ui.tePreview->clear();
-		auto filter = (NgspiceRawBinaryFilter*)this->currentFileFilter();
+		auto* filter = (NgspiceRawBinaryFilter*)this->currentFileFilter();
 		importedStrings = filter->preview(fileName, lines);
 		vectorNameList = filter->vectorNames();
 		columnModes = filter->columnModes();
 		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);
-			auto item = new QTableWidgetItem();
+			auto* 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("imported string " << 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) {
-					auto item = new QTableWidgetItem(importedStrings[i][j]);
+					auto* 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;
 	}
 
 	emit previewRefreshed();
 
 	RESET_CURSOR;
 }
 
 void ImportFileWidget::updateContent(const QString& fileName, AbstractFileFilter::FileType fileType) {
 	initOptionsWidget(fileType);
-	if (auto filter = currentFileFilter()) {
+	if (auto* filter = currentFileFilter()) {
 		switch (fileType) {
 		case AbstractFileFilter::HDF5:
 			m_hdf5OptionsWidget->updateContent((HDF5Filter*)filter, fileName);
 			break;
 		case AbstractFileFilter::NETCDF:
 			m_netcdfOptionsWidget->updateContent((NetCDFFilter*)filter, fileName);
 			break;
 		case AbstractFileFilter::FITS:
 #ifdef HAVE_FITS
 			m_fitsOptionsWidget->updateContent((FITSFilter*)filter, fileName);
 #endif
 			break;
 		case AbstractFileFilter::ROOT:
 			m_rootOptionsWidget->updateContent((ROOTFilter*)filter, fileName);
 			break;
 		case AbstractFileFilter::Ascii:
 		case AbstractFileFilter::Binary:
 		case AbstractFileFilter::Image:
 		case AbstractFileFilter::JSON:
 		case AbstractFileFilter::NgspiceRawAscii:
 		case AbstractFileFilter::NgspiceRawBinary:
 			break;
 		}
 	}
 }
 
 void ImportFileWidget::updateTypeChanged(int idx) {
 	const auto UpdateType = static_cast<LiveDataSource::UpdateType>(idx);
 
 	switch (UpdateType) {
 	case LiveDataSource::UpdateType::TimeInterval:
 		ui.lUpdateInterval->show();
 		ui.sbUpdateInterval->show();
 		break;
 	case LiveDataSource::UpdateType::NewData:
 		ui.lUpdateInterval->hide();
 		ui.sbUpdateInterval->hide();
 	}
 }
 
 void ImportFileWidget::readingTypeChanged(int idx) {
 	const auto readingType = static_cast<LiveDataSource::ReadingType>(idx);
 	const LiveDataSource::SourceType sourceType = currentSourceType();
 
 	if (sourceType == LiveDataSource::SourceType::NetworkTcpSocket || sourceType == LiveDataSource::SourceType::LocalSocket
 			|| sourceType == LiveDataSource::SourceType::SerialPort
 			|| readingType == LiveDataSource::ReadingType::TillEnd || readingType == LiveDataSource::ReadingType::WholeFile) {
 		ui.lSampleSize->hide();
 		ui.sbSampleSize->hide();
 	} else {
 		ui.lSampleSize->show();
 		ui.sbSampleSize->show();
 	}
 
 	if (readingType == LiveDataSource::ReadingType::WholeFile) {
 		ui.lKeepLastValues->hide();
 		ui.sbKeepNValues->hide();
 	} else {
 		ui.lKeepLastValues->show();
 		ui.sbKeepNValues->show();
 	}
 }
 
 void ImportFileWidget::sourceTypeChanged(int idx) {
 	const auto sourceType = static_cast<LiveDataSource::SourceType>(idx);
 
 	// enable/disable "on new data"-option
-	const auto model = qobject_cast<const QStandardItemModel*>(ui.cbUpdateType->model());
+	const auto* model = qobject_cast<const QStandardItemModel*>(ui.cbUpdateType->model());
 	QStandardItem* item = model->item(LiveDataSource::UpdateType::NewData);
 
 	switch (sourceType) {
 	case LiveDataSource::SourceType::FileOrPipe:
 		ui.lFileName->show();
 		ui.leFileName->show();
 		ui.bFileInfo->show();
 		ui.bOpen->show();
 		ui.chbLinkFile->show();
 
 		//option for sample size are available for "continuously fixed" and "from end" reading options
 		if (ui.cbReadingType->currentIndex() < 2) {
 			ui.lSampleSize->show();
 			ui.sbSampleSize->show();
 		} else {
 			ui.lSampleSize->hide();
 			ui.sbSampleSize->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();
 
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
 		fileNameChanged(ui.leFileName->text());
 		ui.cbFileType->show();
 		ui.lFileType->show();
 		setMQTTVisible(false);
 		break;
 	case LiveDataSource::SourceType::NetworkTcpSocket:
 	case LiveDataSource::SourceType::NetworkUdpSocket:
 		ui.lHost->show();
 		ui.leHost->show();
 		ui.lePort->show();
 		ui.lPort->show();
 		if (sourceType == LiveDataSource::SourceType::NetworkTcpSocket) {
 			ui.lSampleSize->hide();
 			ui.sbSampleSize->hide();
 		} else {
 			ui.lSampleSize->show();
 			ui.sbSampleSize->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();
 		ui.chbLinkFile->hide();
 
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 		ui.gbOptions->setEnabled(true);
 		ui.bManageFilters->setEnabled(true);
 		ui.cbFilter->setEnabled(true);
 		ui.cbFileType->setEnabled(true);
 		ui.cbFileType->show();
 		ui.lFileType->show();
 		setMQTTVisible(false);
 		break;
 	case LiveDataSource::SourceType::LocalSocket:
 		ui.lFileName->show();
 		ui.leFileName->show();
 		ui.bOpen->show();
 		ui.lSampleSize->hide();
 		ui.sbSampleSize->hide();
 
 		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();
 		ui.chbLinkFile->hide();
 
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
 		ui.gbOptions->setEnabled(true);
 		ui.bManageFilters->setEnabled(true);
 		ui.cbFilter->setEnabled(true);
 		ui.cbFileType->setEnabled(true);
 		ui.cbFileType->show();
 		ui.lFileType->show();
 		setMQTTVisible(false);
 		break;
 	case LiveDataSource::SourceType::SerialPort:
 		ui.lBaudRate->show();
 		ui.cbBaudRate->show();
 		ui.lSerialPort->show();
 		ui.cbSerialPort->show();
 		ui.lSampleSize->show();
 		ui.sbSampleSize->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();
 		ui.chbLinkFile->hide();
 
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 		ui.cbFileType->setEnabled(true);
 		ui.cbFileType->show();
 		ui.gbOptions->setEnabled(true);
 		ui.bManageFilters->setEnabled(true);
 		ui.cbFilter->setEnabled(true);
 		ui.lFileType->show();
 		setMQTTVisible(false);
 		break;
 	case LiveDataSource::SourceType::MQTT:
 #ifdef HAVE_MQTT
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
 		//for MQTT we read ascii data only, hide the file type options
 		int idx = ui.cbFileType->findText("ASCII data");
 		ui.cbFileType->setCurrentIndex(idx);
 		ui.cbFileType->hide();
 		ui.lFileType->hide();
 
 		ui.lBaudRate->hide();
 		ui.cbBaudRate->hide();
 		ui.lSerialPort->hide();
 		ui.cbSerialPort->hide();
 		ui.lHost->hide();
 		ui.leHost->hide();
 		ui.lPort->hide();
 		ui.lePort->hide();
 		ui.lFileName->hide();
 		ui.leFileName->hide();
 		ui.bFileInfo->hide();
 		ui.bOpen->hide();
 		ui.chbLinkFile->hide();
 
 		setMQTTVisible(true);
 
 		ui.cbFileType->setEnabled(true);
 		ui.gbOptions->setEnabled(true);
 		ui.bManageFilters->setEnabled(true);
 		ui.cbFilter->setEnabled(true);
 
 		//in case there are already connections defined, show the available topics for the currently selected connection
 		mqttConnectionChanged();
 #endif
 		break;
 	}
 
 	//deactivate/activate options that are specific to file of pipe sources only
+	auto* typeModel = qobject_cast<const QStandardItemModel*>(ui.cbFileType->model());
 	if (sourceType != LiveDataSource::FileOrPipe) {
 		//deactivate file types other than ascii and binary
-		auto model = qobject_cast<const QStandardItemModel*>(ui.cbFileType->model());
 		for (int i = 2; i < ui.cbFileType->count(); ++i)
-			model->item(i)->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
+			typeModel->item(i)->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 		//"whole file" read option is available for file or pipe only, disable it
-		model = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
-		QStandardItem* item = model->item(LiveDataSource::ReadingType::WholeFile);
+		typeModel = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
+		QStandardItem* item = typeModel->item(LiveDataSource::ReadingType::WholeFile);
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 		//"update options" groupbox can be deactivated for "file and pipe" if the file is invalid.
 		//Activate the groupbox when switching from "file and pipe" to a different source type.
 		ui.gbUpdateOptions->setEnabled(true);
 	} else {
-		auto model = qobject_cast<const QStandardItemModel*>(ui.cbFileType->model());
 		for (int i = 2; i < ui.cbFileType->count(); ++i)
-			model->item(i)->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+			typeModel->item(i)->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 
 		//enable "whole file" item for file or pipe
-		model = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
-		QStandardItem* item = model->item(LiveDataSource::ReadingType::WholeFile);
+		typeModel = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
+		QStandardItem* item = typeModel->item(LiveDataSource::ReadingType::WholeFile);
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	}
 
 	emit sourceTypeChanged();
 	refreshPreview();
 }
 
 #ifdef HAVE_MQTT
 
 /*!
  *\brief called when a different MQTT connection is selected in the connection ComboBox.
  * connects to the MQTT broker according to the connection settings.
  */
 void ImportFileWidget::mqttConnectionChanged() {
 	if (m_initialisingMQTT)
 		return;
 
 	if (m_client == nullptr || m_client->state() == QMqttClient::ClientState::Disconnected) {
 		if (ui.cbConnection->currentIndex() == -1)
 			return;
 		WAIT_CURSOR;
 
 		delete m_client;
 		m_client = new QMqttClient();
 		connect(m_client, &QMqttClient::connected, this, &ImportFileWidget::onMqttConnect);
 		connect(m_client, &QMqttClient::disconnected, this, &ImportFileWidget::onMqttDisconnect);
 		connect(m_client, &QMqttClient::messageReceived, this, &ImportFileWidget::mqttMessageReceived);
 		connect(m_client, &QMqttClient::errorChanged, this, &ImportFileWidget::mqttErrorChanged);
 
 		ui.cbConnection->setEnabled(false);
 		ui.bManageConnections->setEnabled(false);
 
 		//determine the current connection's settings
 		KConfig config(m_configPath, KConfig::SimpleConfig);
 		KConfigGroup group = config.group(ui.cbConnection->currentText());
 
 		m_client->setHostname(group.readEntry("Host"));
 		m_client->setPort(group.readEntry("Port").toUInt());
 
 		bool useID = group.readEntry("UseID").toUInt();
 		if (useID)
 			m_client->setClientId(group.readEntry("ClientID"));
 		else
 			m_client->setClientId("");
 
 		bool useAuthentication = group.readEntry("UseAuthentication").toUInt();
 		if (useAuthentication) {
 			m_client->setUsername(group.readEntry("UserName"));
 			m_client->setPassword(group.readEntry("Password"));
 		} else {
 			m_client->setUsername("");
 			m_client->setPassword("");
 		}
 
 		qDebug()<< "Use ID" << useID << " " << m_client->clientId();
 		qDebug()<< "Use authentication" << useAuthentication << " " << m_client->username() << " " << m_client->password();
 		qDebug()<< m_client->hostname() << "   " << m_client->port();
 		qDebug()<< "Trying to connect";
 		m_connectTimeoutTimer->start();
 		m_client->connectToHost();
 	} else if (m_client->state() == QMqttClient::ClientState::Connected) {
 		WAIT_CURSOR;
 		ui.cbConnection->setEnabled(false);
 		ui.bManageConnections->setEnabled(false);
 		qDebug()<<"Disconnecting from MQTT broker"	;
 		m_client->disconnectFromHost();
 	}
 }
 
 /*!
  *\brief called when the client connects to the broker successfully, it subscribes to every topic (# wildcard)
  * in order to later list every available topic
  */
 void ImportFileWidget::onMqttConnect() {
 	if (m_client->error() == QMqttClient::NoError) {
 		m_connectTimeoutTimer->stop();
 		ui.gbManageSubscriptions->setVisible(true);
 
 		//subscribing to every topic (# wildcard) in order to later list every available topic
 		QMqttTopicFilter globalFilter{"#"};
 		m_mainSubscription = m_client->subscribe(globalFilter, 1);
 		if (!m_mainSubscription)
 			QMessageBox::critical(this, i18n("Couldn't subscribe"), i18n("Couldn't subscribe. Something went wrong"));
 	}
 	ui.cbConnection->setEnabled(true);
 	ui.bManageConnections->setEnabled(true);
 	emit subscriptionsChanged();
 	RESET_CURSOR;
 }
 
 /*!
  *\brief called when the client disconnects from the broker successfully
  * removes every information about the former connection
  */
 void ImportFileWidget::onMqttDisconnect() {
 	ui.gbManageSubscriptions->setVisible(false);
 	ui.twSubscriptions->clear();
 	ui.twTopics->clear();
 
 	ui.cbSourceType->setEnabled(true);
 
 	m_mqttReadyForPreview = false;
 	m_mqttSubscriptions.clear();
 
 	m_topicCompleter = new QCompleter;
 	m_subscriptionCompleter = new QCompleter;
 
 	m_topicList.clear();
 	m_searching = false;
 	m_searchTimer->stop();
 	m_connectTimeoutTimer->stop();
 	m_messageArrived.clear();
 	m_lastMessage.clear();
 
 	emit subscriptionsChanged();
 	RESET_CURSOR;
 
 	ui.cbConnection->setEnabled(true);
 	ui.bManageConnections->setEnabled(true);
 
 	if (!m_initialisingMQTT) {
 		if (!m_connectionTimedOut)
 			QTimer::singleShot(300, this, &ImportFileWidget::mqttConnectionChanged);
 		else
 			m_connectionTimedOut = false;
 	}
 }
 
 /*!
  *\brief called when the subscribe button is pressed
  * subscribes to the topic represented by the current item of twTopics
  */
 void ImportFileWidget::mqttSubscribe() {
 	QTreeWidgetItem* item = ui.twTopics->currentItem();
 	if (!item) {
 		QMessageBox::warning(this, i18n("Warning"), i18n("You didn't select any item from the Tree Widget"));
 		return;
 	}
 
 	//determine the topic name that the current item represents
 	QTreeWidgetItem*tempItem = item;
 	QString name = item->text(0);
 	if (item->childCount() != 0)
 		name.append("/#");
 
 	while(tempItem->parent() != nullptr) {
 		tempItem = tempItem->parent();
 		name.prepend(tempItem->text(0) + '/');
 	}
 
 	//check if the subscription already exists
 	const QList<QTreeWidgetItem*>& topLevelList = ui.twSubscriptions->findItems(name, Qt::MatchExactly);
 	if (topLevelList.isEmpty() || topLevelList.first()->parent() != nullptr) {
 		qDebug() << "Subscribe to: " << name;
 		bool foundSuperior = false;
 
 		for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 			//if the new subscirptions contains an already existing one, we remove the inferior one
 			if (checkTopicContains(name, ui.twSubscriptions->topLevelItem(i)->text(0))
 					&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 				unsubscribeFromTopic(ui.twSubscriptions->topLevelItem(i)->text(0));
 				i--;
 				continue;
 			}
 
 			//if there is a subscription containing the new one we set foundSuperior true
 			if (checkTopicContains(ui.twSubscriptions->topLevelItem(i)->text(0), name)
 					&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 				foundSuperior = true;
 				qDebug()<<"Can't continue subscribe. Found superior for " << name <<" : "<< ui.twSubscriptions->topLevelItem(i)->text(0);
 				break;
 			}
 		}
 
 		//if there wasn't a superior subscription we can subscribe to the new topic
 		if (!foundSuperior) {
 			QStringList toplevelName;
 			toplevelName.push_back(name);
 			QTreeWidgetItem* newTopLevelItem = new QTreeWidgetItem(toplevelName);
 			ui.twSubscriptions->addTopLevelItem(newTopLevelItem);
 
 			QMqttTopicFilter filter {name};
 			QMqttSubscription *temp_subscription = m_client->subscribe(filter, static_cast<quint8> (ui.cbQos->currentText().toUInt()) );
 
 			if (temp_subscription) {
 				m_mqttSubscriptions.push_back(temp_subscription);
 				connect(temp_subscription, &QMqttSubscription::messageReceived, this, &ImportFileWidget::mqttSubscriptionMessageReceived);
 				emit subscriptionsChanged();
 			}
 
 			if (name.endsWith('#')) {
 				//adding every topic that the subscription contains to twSubscriptions
 				addSubscriptionChildren(item, newTopLevelItem);
 
 				//if an already existing subscription contains a topic that the new subscription also contains
 				//we decompose the already existing subscription
 				//by unsubscribing from its topics, that are present in the new subscription as well
 				QStringList nameList = name.split('/', QString::SkipEmptyParts);
 				QString root = nameList.first();
 				QVector<QTreeWidgetItem*> children;
 				for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 					if (ui.twSubscriptions->topLevelItem(i)->text(0).startsWith(root)
 							&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 						children.clear();
 						//get the "leaf" children of the inspected subscription
 						findSubscriptionLeafChildren(children, ui.twSubscriptions->topLevelItem(i));
 						for (int j = 0; j < children.size(); ++j) {
 							if (checkTopicContains(name, children[j]->text(0))) {
 								//if the new subscription contains a topic, we unsubscribe from it
 								ui.twSubscriptions->setCurrentItem(children[j]);
 								mqttUnsubscribe();
 								i--;
 							}
 						}
 					}
 				}
 			}
 
 			manageCommonLevelSubscriptions();
 			updateSubscriptionCompleter();
 
 			if(!ui.bWillMessage->isEnabled())
 				ui.bWillMessage->setEnabled(true);
 		} else
 			QMessageBox::warning(this, i18n("Warning"), i18n("You already subscribed to a topic containing this one"));
 	} else
 		QMessageBox::warning(this, i18n("Warning"), i18n("You already subscribed to this topic"));
 }
 
 /*!
  *\brief called when the unsubscribe button is pressed
  * unsubscribes from the topic represented by the current item of twSubscription
  */
 void ImportFileWidget::mqttUnsubscribe() {
 	QTreeWidgetItem* unsubscribeItem = ui.twSubscriptions->currentItem();
 	if (!unsubscribeItem) {
 		QMessageBox::warning(this, i18n("Warning"), i18n("You didn't select any item from the Tree Widget"));
 		return;
 	}
 
 	qDebug() << "Unsubscribe from: " << unsubscribeItem->text(0);
 	//if it is a top level item, meaning a topic that we really subscribed to(not one that belongs to a subscription)
 	//we can simply unsubscribe from it
 	if (unsubscribeItem->parent() == nullptr)
 		unsubscribeFromTopic(unsubscribeItem->text(0));
 
 	//otherwise we remove the selected item, but subscribe to every other topic, that was contained by
 	//the selected item's parent subscription(top level item of twSubscriptions)
 	else {
 		while(unsubscribeItem->parent() != nullptr) {
 			for (int i = 0; i < unsubscribeItem->parent()->childCount(); ++i) {
 				if (unsubscribeItem->text(0) != unsubscribeItem->parent()->child(i)->text(0)) {
 					QMqttTopicFilter filter {unsubscribeItem->parent()->child(i)->text(0)};
 					QMqttSubscription *temp_subscription = m_client->subscribe(filter, static_cast<quint8> (ui.cbQos->currentText().toUInt()) );
 
 					ui.twSubscriptions->addTopLevelItem(unsubscribeItem->parent()->takeChild(i));
 
 					if (temp_subscription) {
 						m_mqttSubscriptions.push_back(temp_subscription);
 						connect(temp_subscription, &QMqttSubscription::messageReceived, this, &ImportFileWidget::mqttSubscriptionMessageReceived);
 						emit subscriptionsChanged();
 					}
 					i--;
 				}
 			}
 			unsubscribeItem = unsubscribeItem->parent();
 		}
 		unsubscribeFromTopic(unsubscribeItem->text(0));
 
 		//check if any common topics were subscribed, if possible merge them
 		manageCommonLevelSubscriptions();
 	}
 	updateSubscriptionCompleter();
 
 	if(ui.twSubscriptions->topLevelItemCount() <= 0)
 		ui.bWillMessage->setEnabled(false);
 }
 
 /*!
  *\brief called when the client receives a message
  * if the message arrived from a new topic, the topic is put in twTopics
  */
 void ImportFileWidget::mqttMessageReceived(const QByteArray &message , const QMqttTopicName &topic) {
 	Q_UNUSED(message);
 	if (m_addedTopics.contains(topic.name()))
 		return;
 
 	m_addedTopics.push_back(topic.name());
 	QStringList name;
 	QChar sep = '/';
 	QString rootName;
 	if (topic.name().contains(sep)) {
 		const QStringList& list = topic.name().split(sep, QString::SkipEmptyParts);
 
 		if (!list.isEmpty()) {
 			rootName = list.at(0);
 			name.append(list.at(0));
 			QTreeWidgetItem* currentItem;
 			int topItemIdx = -1;
 			//check whether the first level of the topic can be found in twTopics
 			for (int i = 0; i < ui.twTopics->topLevelItemCount(); ++i) {
 				if (ui.twTopics->topLevelItem(i)->text(0) == list.at(0)) {
 					topItemIdx = i;
 					break;
 				}
 			}
 			//if not we simply add every level of the topic to the tree
 			if (topItemIdx < 0) {
 				currentItem = new QTreeWidgetItem(name);
 				ui.twTopics->addTopLevelItem(currentItem);
 				for (int i = 1; i < list.size(); ++i) {
 					name.clear();
 					name.append(list.at(i));
 					currentItem->addChild(new QTreeWidgetItem(name));
 					currentItem = currentItem->child(0);
 				}
 			}
 			//otherwise we search for the first level that isn't part of the tree,
 			//then add every level of the topic to the tree from that certain level
 			else {
 				currentItem = ui.twTopics->topLevelItem(topItemIdx);
 				int listIdx = 1;
 				for (; listIdx < list.size(); ++listIdx) {
 					QTreeWidgetItem* childItem = nullptr;
 					bool found = false;
 					for (int j = 0; j < currentItem->childCount(); ++j) {
 						childItem = currentItem->child(j);
 						if (childItem->text(0) == list.at(listIdx)) {
 							found = true;
 							currentItem = childItem;
 							break;
 						}
 					}
 					if (!found) {
 						//this is the level that isn't present in the tree
 						break;
 					}
 				}
 
 				//add every level to the tree starting with the first level that isn't part of the tree
 				for (; listIdx < list.size(); ++listIdx) {
 					name.clear();
 					name.append(list.at(listIdx));
 					currentItem->addChild(new QTreeWidgetItem(name));
 					currentItem = currentItem->child(currentItem->childCount() - 1);
 				}
 			}
 		}
 	} else {
 		rootName = topic.name();
 		name.append(topic.name());
 		ui.twTopics->addTopLevelItem(new QTreeWidgetItem(name));
 	}
 
 	//if a subscribed topic contains the new topic, we have to update twSubscriptions
 	for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 		QStringList subscriptionName = ui.twSubscriptions->topLevelItem(i)->text(0).split('/', QString::SkipEmptyParts);
 		if (!subscriptionName.isEmpty()) {
 			if (rootName == subscriptionName.first()) {
 				updateSubscriptionTree();
 				break;
 			}
 		}
 	}
 
 	//signals that a newTopic was added, in order to fill the completer of leTopics
 	emit newTopic(rootName);
 }
 
 /*!
  *\brief called when a new topic is added to the tree(twTopics)
  * appends the topic's root to the topicList if it isn't in the list already
  * then sets the completer for leTopics
  */
 void ImportFileWidget::setTopicCompleter(const QString& topic) {
 	if (!m_topicList.contains(topic)) {
 		m_topicList.append(topic);
 		if (!m_searching) {
 			m_topicCompleter = new QCompleter(m_topicList, this);
 			m_topicCompleter->setCompletionMode(QCompleter::PopupCompletion);
 			m_topicCompleter->setCaseSensitivity(Qt::CaseSensitive);
 			ui.leTopics->setCompleter(m_topicCompleter);
 		}
 	}
 }
 
 /*!
  *\brief called when 10 seconds passed since the last time the user searched for a certain root in twTopics
  * enables updating the completer for le
  */
 void ImportFileWidget::topicTimeout() {
 	m_searching = false;
 	m_searchTimer->stop();
 }
 
 /*!
  *\brief called when the client receives a message from a subscribed topic (that isn't the "#" wildcard)
  */
 void ImportFileWidget::mqttSubscriptionMessageReceived(const QMqttMessage &msg) {
 	qDebug()<<"message received from: "<<msg.topic().name();
 	if (!m_subscribedTopicNames.contains(msg.topic().name())) {
 		m_messageArrived[msg.topic()] = true;
 		m_subscribedTopicNames.push_back(msg.topic().name());
 	}
 
 	if (m_messageArrived[msg.topic()] == false)
 		m_messageArrived[msg.topic()] = true;
 
 	//updates the last message of the topic
 	m_lastMessage[msg.topic()]= msg;
 
 	//check if the client received a message from every subscribed topic, since the last time the preview was refreshed
 	bool check = true;
 	QMapIterator<QMqttTopicName, bool> i(m_messageArrived);
 	while(i.hasNext()) {
 		i.next();
 		if (i.value() == false ) {
 			check = false;
 			break;
 		}
 	}
 
 	//if there is a message from every subscribed topic, we refresh the preview
 	if (check == true) {
 		m_mqttReadyForPreview = true;
 		refreshPreview();
 	}
 }
 
 /*!
  *\brief called when use will message is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::useWillMessage(int state) {
 	if (state == Qt::Checked)
 		m_willSettings.MQTTUseWill = true;
 	else if (state == Qt::Unchecked)
 		m_willSettings.MQTTUseWill = false;
 }
 
 /*!
  *\brief called when the selected will message type is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willMessageTypeChanged(int type) {
 	m_willSettings.willMessageType = static_cast<MQTTClient::WillMessageType>(type);
 }
 
 /*!
  *\brief called when the selected will message' type's retain flag is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willRetainChanged(bool retain) {
 	m_willSettings.willRetain = retain;
 }
 
 /*!
  *\brief called when the selected will update interval is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willTimeIntervalChanged(int interval) {
 	m_willSettings.willTimeInterval = interval;
 }
 
 /*!
  *\brief called when the selected will own message is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willOwnMessageChanged(const QString& msg) {
 	m_willSettings.willOwnMessage = msg;
 }
 
 /*!
  *\brief called when the selected will topic is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willTopicChanged(const QString& topic) {
 	m_willSettings.willTopic = topic;
 }
 
 /*!
  *\brief called when the selected will statistics are changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willStatisticsChanged(int index) {
 	m_willSettings.willStatistics[index] = !m_willSettings.willStatistics[index];
 }
 
 /*!
  *\brief called when the selected will message's QoS is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willQoSChanged(int qos) {
 	m_willSettings.willQoS = qos;
 }
 
 /*!
  *\brief called when the selected will update type is changed in the settings widget
  * Updates the will settings
  */
 void ImportFileWidget::willUpdateTypeChanged(int updateType) {
 	qDebug() << "update type changed: " <<updateType;
 	m_willSettings.willUpdateType = static_cast<MQTTClient::WillUpdateType>(updateType);
 }
 
 /*!
  *\brief called when the clientError of the MQTT client changes
  *
  * \param clientError the current error of the client
  */
 void ImportFileWidget::mqttErrorChanged(QMqttClient::ClientError clientError) {
 	switch (clientError) {
 	case QMqttClient::BadUsernameOrPassword:
 		QMessageBox::critical(this, i18n("Couldn't connect"), i18n("Wrong username or password"));
 		break;
 	case QMqttClient::IdRejected:
 		QMessageBox::critical(this, i18n("Couldn't connect"), i18n("The client ID wasn't accepted"));
 		break;
 	case QMqttClient::ServerUnavailable:
 		QMessageBox::critical(this, i18n("Server unavailable"), i18n("The broker couldn't be reached."));
 		break;
 	case QMqttClient::NotAuthorized:
 		QMessageBox::critical(this, i18n("Not authorized"), i18n("The client is not authorized to connect."));
 		break;
 	case QMqttClient::UnknownError:
 		QMessageBox::critical(this, i18n("Unknown MQTT error"), i18n("An unknown error occurred."));
 		break;
 	case QMqttClient::NoError:
 	case QMqttClient::InvalidProtocolVersion:
 	case QMqttClient::TransportInvalid:
 	case QMqttClient::ProtocolViolation:
 		break;
 	default:
 		break;
 	}
 }
 
 /*!
  *\brief called when leTopics' text is changed
  *		 if the rootName can be found in twTopics, then we scroll it to the top of the tree widget
  *
  * \param rootName the current text of leTopics
  */
 void ImportFileWidget::scrollToTopicTreeItem(const QString& rootName) {
 	m_searching = true;
 	m_searchTimer->start();
 
 	int topItemIdx = -1;
 	for (int i = 0; i < ui.twTopics->topLevelItemCount(); ++i)
 		if (ui.twTopics->topLevelItem(i)->text(0) == rootName) {
 			topItemIdx = i;
 			break;
 		}
 
 	if (topItemIdx >= 0)
 		ui.twTopics->scrollToItem(ui.twTopics->topLevelItem(topItemIdx), QAbstractItemView::ScrollHint::PositionAtTop);
 }
 
 /*!
  *\brief called when leSubscriptions' text is changed
  *		 if the rootName can be found in twSubscriptions, then we scroll it to the top of the tree widget
  *
  * \param rootName the current text of leSubscriptions
  */
 void ImportFileWidget::scrollToSubsriptionTreeItem(const QString& rootName) {
 	m_searching = true;
 	m_searchTimer->start();
 
 	int topItemIdx = -1;
 	for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i)
 		if (ui.twSubscriptions->topLevelItem(i)->text(0) == rootName) {
 			topItemIdx = i;
 			break;
 		}
 
 	if (topItemIdx >= 0)
 		ui.twSubscriptions->scrollToItem(ui.twSubscriptions->topLevelItem(topItemIdx), QAbstractItemView::ScrollHint::PositionAtTop);
 }
 
 /*!
  *\brief called when m_connectTimeoutTimer ticks,
  *		 meaning that the client couldn't connect to the broker in 5 seconds
  *		 disconnects the client, stops the timer, and warns the user
  */
 void ImportFileWidget::mqttConnectTimeout() {
 	m_connectionTimedOut = true;
 	m_client->disconnectFromHost();
 	m_connectTimeoutTimer->stop();
 	QMessageBox::warning(this, i18n("Warning"), i18n("Connecting to the given broker timed out! Try changing the settings"));
 	RESET_CURSOR;
 }
 
 /*!
 	shows the MQTT connection manager where the connections are created and edited.
 	The selected connection is selected in the connection combo box in this widget.
 */
 void ImportFileWidget::showMQTTConnectionManager() {
 	bool previousConnectionChanged = false;
 	MQTTConnectionManagerDialog* dlg = new MQTTConnectionManagerDialog(this, ui.cbConnection->currentText(), &previousConnectionChanged);
 
 	if (dlg->exec() == QDialog::Accepted) {
 
 		//re-read the available connections to be in sync with the changes in MQTTConnectionManager
 		m_initialisingMQTT = true;
 		QString prevConn = ui.cbConnection->currentText();
 		ui.cbConnection->clear();
 		readMQTTConnections();
 		m_initialisingMQTT = false;
 
 		//select the connection the user has selected in MQTTConnectionManager
 		QString conn = dlg->connection();
 
 		int index = ui.cbConnection->findText(conn);
 		if (conn != prevConn) {//Current connection isn't the previous one
 			if (ui.cbConnection->currentIndex() != index)
 				ui.cbConnection->setCurrentIndex(index);
 			else
 				mqttConnectionChanged();
 		} else if (previousConnectionChanged) {//Current connection is the same with previous one but it changed
 			if (ui.cbConnection->currentIndex() == index)
 				mqttConnectionChanged();
 			else
 				ui.cbConnection->setCurrentIndex(index);
 		} else { //Previous connection wasn't changed
 			m_initialisingMQTT = true;
 			ui.cbConnection->setCurrentIndex(index);
 			m_initialisingMQTT = false;
 		}
 	}
 	delete dlg;
 }
 
 /*!
 	loads all available saved MQTT nconnections
 */
 void ImportFileWidget::readMQTTConnections() {
 	qDebug()<< "ImportFileWidget: reading available MQTT connections";
 	KConfig config(m_configPath, KConfig::SimpleConfig);
 	for (const auto& name : config.groupList())
 		ui.cbConnection->addItem(name);
 }
 
 /*!
  * \brief Shows the mqtt will settings widget, which allows the user to modify the will settings
  */
 void ImportFileWidget::showWillSettings() {
 	QMenu menu;
 
 	QVector<QTreeWidgetItem*> children;
 	for (int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 		findSubscriptionLeafChildren(children, ui.twSubscriptions->topLevelItem(i));
 	}
 
 	QVector<QString> topics;
 	for (int i = 0; i < children.size(); ++i) {
 		topics.append(children[i]->text(0));
 	}
 	MQTTWillSettingsWidget willSettings(&menu, m_willSettings, topics);
 
 	connect(&willSettings, &MQTTWillSettingsWidget::useChanged, this, &ImportFileWidget::useWillMessage);
 	connect(&willSettings, &MQTTWillSettingsWidget::messageTypeChanged, this, &ImportFileWidget::willMessageTypeChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::updateTypeChanged, this, &ImportFileWidget::willUpdateTypeChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::retainChanged, this, &ImportFileWidget::willRetainChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::intervalChanged, this, &ImportFileWidget::willTimeIntervalChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::ownMessageChanged, this, &ImportFileWidget::willOwnMessageChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::topicChanged, this, &ImportFileWidget::willTopicChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::statisticsChanged, this, &ImportFileWidget::willStatisticsChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::QoSChanged, this, &ImportFileWidget::willQoSChanged);
 	connect(&willSettings, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&willSettings);
 	menu.addAction(widgetAction);
 
 	QPoint pos(ui.bWillMessage->sizeHint().width(),ui.bWillMessage->sizeHint().height());
 	menu.exec(ui.bWillMessage->mapToGlobal(pos));
 }
 #endif
diff --git a/src/kdefrontend/datasources/ImportProjectDialog.cpp b/src/kdefrontend/datasources/ImportProjectDialog.cpp
index 72b243325..8f63026f0 100644
--- a/src/kdefrontend/datasources/ImportProjectDialog.cpp
+++ b/src/kdefrontend/datasources/ImportProjectDialog.cpp
@@ -1,423 +1,423 @@
 /***************************************************************************
     File                 : ImportProjectDialog.cpp
     Project              : LabPlot
     Description          : import project dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2017 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ImportProjectDialog.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/datasources/projects/LabPlotProjectParser.h"
 #ifdef HAVE_LIBORIGIN
 #include "backend/datasources/projects/OriginProjectParser.h"
 #endif
 #include "kdefrontend/MainWin.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QProgressBar>
 #include <QStatusBar>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 /*!
     \class ImportProjectDialog
     \brief Dialog for importing project files.
 
 	\ingroup kdefrontend
  */
 ImportProjectDialog::ImportProjectDialog(MainWin* parent, ProjectType type) : QDialog(parent),
 	m_mainWin(parent),
 	m_projectParser(nullptr),
 	m_projectType(type),
 	m_aspectTreeModel(new AspectTreeModel(parent->project())) {
 
-	auto vLayout = new QVBoxLayout(this);
+	auto* vLayout = new QVBoxLayout(this);
 
 	//main widget
 	QWidget* mainWidget = new QWidget(this);
 	ui.setupUi(mainWidget);
 	ui.chbUnusedObjects->hide();
 	vLayout->addWidget(mainWidget);
 
 	ui.tvPreview->setAnimated(true);
 	ui.tvPreview->setAlternatingRowColors(true);
 	ui.tvPreview->setSelectionBehavior(QAbstractItemView::SelectRows);
 	ui.tvPreview->setSelectionMode(QAbstractItemView::ExtendedSelection);
 	ui.tvPreview->setUniformRowHeights(true);
 
 	ui.bOpen->setIcon( QIcon::fromTheme("document-open") );
 
 	m_cbAddTo = new TreeViewComboBox(ui.gbImportTo);
 	m_cbAddTo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 	ui.gbImportTo->layout()->addWidget(m_cbAddTo);
 
 	QList<const char*> list;
 	list << "Folder";
 	m_cbAddTo->setTopLevelClasses(list);
 	m_aspectTreeModel->setSelectableAspects(list);
 	m_cbAddTo->setModel(m_aspectTreeModel);
 
 	m_bNewFolder = new QPushButton(ui.gbImportTo);
 	m_bNewFolder->setIcon(QIcon::fromTheme("list-add"));
 	m_bNewFolder->setToolTip(i18n("Add new folder"));
 	ui.gbImportTo->layout()->addWidget(m_bNewFolder);
 
 	//dialog buttons
 	m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 	vLayout->addWidget(m_buttonBox);
 
 	//ok-button is only enabled if some project objects were selected (s.a. ImportProjectDialog::selectionChanged())
 	m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 
 	//Signals/Slots
 	connect(ui.leFileName, SIGNAL(textChanged(QString)), SLOT(fileNameChanged(QString)));
 	connect(ui.bOpen, SIGNAL(clicked()), this, SLOT (selectFile()));
 	connect(m_bNewFolder, SIGNAL(clicked()), this, SLOT(newFolder()));
 	connect(ui.chbUnusedObjects, &QCheckBox::stateChanged, this, &ImportProjectDialog::refreshPreview);
 	connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
 	QString title;
 	switch (m_projectType) {
 	case (ProjectLabPlot):
 		m_projectParser = new LabPlotProjectParser();
 		title = i18nc("@title:window", "Import LabPlot Project");
 		break;
 	case (ProjectOrigin):
 #ifdef HAVE_LIBORIGIN
 		m_projectParser = new OriginProjectParser();
 		title = i18nc("@title:window", "Import Origin Project");
 #endif
 		break;
 	}
 
 	//dialog title and icon
 	setWindowTitle(title);
 	setWindowIcon(QIcon::fromTheme("document-import"));
 
 	QTimer::singleShot(0, this, &ImportProjectDialog::loadSettings);
 }
 
 void ImportProjectDialog::loadSettings() {
 	//restore saved settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportProjectDialog");
 	KWindowConfig::restoreWindowSize(windowHandle(), conf);
 
 	QString lastImportedFile;
 	switch (m_projectType) {
 	case (ProjectLabPlot):
 		lastImportedFile = QLatin1String("LastImportedLabPlotProject");
 		break;
 	case (ProjectOrigin):
 		lastImportedFile = QLatin1String("LastImportedOriginProject");
 		break;
 	}
 
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 	ui.leFileName->setText(conf.readEntry(lastImportedFile, ""));
 }
 
 ImportProjectDialog::~ImportProjectDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportProjectDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 
 	QString lastImportedFile;
 	switch (m_projectType) {
 	case (ProjectLabPlot):
 		lastImportedFile = QLatin1String("LastImportedLabPlotProject");
 		break;
 	case (ProjectOrigin):
 		lastImportedFile = QLatin1String("LastImportedOriginProject");
 		break;
 	}
 
 	conf.writeEntry(lastImportedFile, ui.leFileName->text());
 }
 
 void ImportProjectDialog::setCurrentFolder(const Folder* folder) {
 	m_cbAddTo->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(folder));
 }
 
 void ImportProjectDialog::importTo(QStatusBar* statusBar) const {
 	DEBUG("ImportProjectDialog::importTo()");
 
 	//determine the selected objects, convert the model indexes to string pathes
 	const QModelIndexList& indexes = ui.tvPreview->selectionModel()->selectedIndexes();
 	QStringList selectedPathes;
 	for (int i = 0; i < indexes.size()/4; ++i) {
 		QModelIndex index = indexes.at(i*4);
-		const auto aspect = static_cast<const AbstractAspect*>(index.internalPointer());
+		const auto* aspect = static_cast<const AbstractAspect*>(index.internalPointer());
 
 		//path of the current aspect and the pathes of all aspects it depends on
 		selectedPathes << aspect->path();
 		QDEBUG(" aspect path: " << aspect->path());
 		for (const auto* depAspect : aspect->dependsOn())
 			selectedPathes << depAspect->path();
 	}
 	selectedPathes.removeDuplicates();
 
 	Folder* targetFolder = static_cast<Folder*>(m_cbAddTo->currentModelIndex().internalPointer());
 
 	//check whether the selected pathes already exist in the target folder and warn the user
 	const QString& targetFolderPath = targetFolder->path();
 	const Project* targetProject = targetFolder->project();
 	QStringList targetAllPathes;
 	for (const auto* aspect : targetProject->children<AbstractAspect>(AbstractAspect::Recursive)) {
 		if (!dynamic_cast<const Folder*>(aspect))
 			targetAllPathes << aspect->path();
 	}
 
 	QStringList existingPathes;
 	for (const auto& path : selectedPathes) {
 		const QString& newPath = targetFolderPath + path.right(path.length() - path.indexOf('/'));
 		if (targetAllPathes.indexOf(newPath) != -1)
 			existingPathes << path;
 	}
 
 	QDEBUG("project objects to be imported: " << selectedPathes);
 	QDEBUG("all already available project objects: " << targetAllPathes);
 	QDEBUG("already available project objects to be overwritten: " << existingPathes);
 
 	if (!existingPathes.isEmpty()) {
 		QString msg = i18np("The object listed below already exists in target folder and will be overwritten:",
 							"The objects listed below already exist in target folder and will be overwritten:",
 							existingPathes.size());
 		msg += '\n';
 		for (const auto& path : existingPathes)
 			msg += '\n' + path.right(path.length() - path.indexOf('/') - 1); //strip away the name of the root folder "Project"
 		msg += "\n\n" + i18n("Do you want to proceed?");
 
 		const int rc = KMessageBox::warningYesNo(nullptr, msg, i18n("Override existing objects?"));
 		if (rc == KMessageBox::No)
 			return;
 	}
 
 	//show a progress bar in the status bar
-	auto progressBar = new QProgressBar();
+	auto* progressBar = new QProgressBar();
 	progressBar->setMinimum(0);
 	progressBar->setMaximum(100);
 
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 
 	//import the selected project objects into the specified folder
 	QTime timer;
 	timer.start();
 	connect(m_projectParser, SIGNAL(completed(int)), progressBar, SLOT(setValue(int)));
 
 #ifdef HAVE_LIBORIGIN
 	if (m_projectType == ProjectOrigin && ui.chbUnusedObjects->isVisible() && ui.chbUnusedObjects->isChecked())
 		reinterpret_cast<OriginProjectParser*>(m_projectParser)->setImportUnusedObjects(true);
 #endif
 
 	m_projectParser->importTo(targetFolder, selectedPathes);
 	statusBar->showMessage( i18n("Project data imported in %1 seconds.", (float)timer.elapsed()/1000) );
 
 	QApplication::restoreOverrideCursor();
 	statusBar->removeWidget(progressBar);
 }
 
 /*!
  * show the content of the project in the tree view
  */
 void ImportProjectDialog::refreshPreview() {
 	QString project = ui.leFileName->text();
 	m_projectParser->setProjectFileName(project);
 
 #ifdef HAVE_LIBORIGIN
 	if (m_projectType == ProjectOrigin) {
-		const auto originParser = reinterpret_cast<OriginProjectParser*>(m_projectParser);
+		auto* originParser = reinterpret_cast<OriginProjectParser*>(m_projectParser);
 		if (originParser->hasUnusedObjects())
 			ui.chbUnusedObjects->show();
 		else
 			ui.chbUnusedObjects->hide();
 
 		originParser->setImportUnusedObjects(ui.chbUnusedObjects->isVisible() && ui.chbUnusedObjects->isChecked());
 	}
 #endif
 
 	ui.tvPreview->setModel(m_projectParser->model());
 
 	connect(ui.tvPreview->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
 			this, SLOT(selectionChanged(QItemSelection,QItemSelection)) );
 
 	//show top-level containers only
 	if (ui.tvPreview->model()) {
 		QModelIndex root = ui.tvPreview->model()->index(0,0);
 		showTopLevelOnly(root);
 	}
 
 	//extand the tree to show all available top-level objects and adjust the header sizes
 	ui.tvPreview->expandAll();
 	ui.tvPreview->header()->resizeSections(QHeaderView::ResizeToContents);
 }
 
 /*!
 	Hides the non-toplevel items of the model used in the tree view.
 */
 void ImportProjectDialog::showTopLevelOnly(const QModelIndex& index) {
 	int rows = index.model()->rowCount(index);
 	for (int i = 0; i < rows; ++i) {
 		QModelIndex child = index.child(i, 0);
 		showTopLevelOnly(child);
-		const auto aspect = static_cast<const AbstractAspect*>(child.internalPointer());
+		const auto* aspect = static_cast<const AbstractAspect*>(child.internalPointer());
 		ui.tvPreview->setRowHidden(i, index, !isTopLevel(aspect));
 	}
 }
 
 /*!
 	checks whether \c aspect is one of the allowed top level types
 */
 bool ImportProjectDialog::isTopLevel(const AbstractAspect* aspect) const {
 	foreach (const char* classString, m_projectParser->topLevelClasses()) {
 		if (aspect->inherits(classString))
 				return true;
 	}
 	return false;
 }
 
 //##############################################################################
 //#################################  SLOTS  ####################################
 //##############################################################################
 void ImportProjectDialog::selectionChanged(const QItemSelection& selected, const QItemSelection& deselected) {
 	Q_UNUSED(deselected);
 
 	//determine the dependent objects and select/deselect them too
 	const QModelIndexList& indexes = selected.indexes();
 	if (indexes.isEmpty())
 		return;
 
 	//for the just selected aspect, determine all the objects it depends on and select them, too
 	//TODO: we need a better "selection", maybe with tri-state check boxes in the tree view
-	const auto aspect = static_cast<const AbstractAspect*>(indexes.at(0).internalPointer());
+	const auto* aspect = static_cast<const AbstractAspect*>(indexes.at(0).internalPointer());
 	const QVector<AbstractAspect*> aspects = aspect->dependsOn();
-	const auto model = reinterpret_cast<AspectTreeModel*>(ui.tvPreview->model());
+	const auto* model = reinterpret_cast<AspectTreeModel*>(ui.tvPreview->model());
 	for (const auto* aspect : aspects) {
 		QModelIndex index = model->modelIndexOfAspect(aspect, 0);
 		ui.tvPreview->selectionModel()->select(index, QItemSelectionModel::Select | QItemSelectionModel::Rows);
 	}
 
 
 	//Ok-button is only enabled if some project objects were selected
 	bool enable = (selected.indexes().size() != 0);
 	m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(enable);
 	if (enable)
 		m_buttonBox->button(QDialogButtonBox::Ok)->setToolTip(i18n("Close the dialog and import the selected objects."));
 	else
 		m_buttonBox->button(QDialogButtonBox::Ok)->setToolTip(i18n("Select object(s) to be imported."));
 }
 
 /*!
 	opens a file dialog and lets the user select the project file.
 */
 void ImportProjectDialog::selectFile() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportProjectDialog");
 
 	QString title;
 	QString lastDir;
 	QString supportedFormats;
 	QString lastDirConfEntryName;
 	switch (m_projectType) {
 	case (ProjectLabPlot):
 		title = i18nc("@title:window", "Open LabPlot Project");
 		lastDirConfEntryName = QLatin1String("LastImportLabPlotProjectDir");
 		supportedFormats = i18n("LabPlot Projects (%1)", Project::supportedExtensions());
 		break;
 	case (ProjectOrigin):
 #ifdef HAVE_LIBORIGIN
 		title = i18nc("@title:window", "Open Origin Project");
 		lastDirConfEntryName = QLatin1String("LastImportOriginProjecttDir");
 		supportedFormats = i18n("Origin Projects (%1)", OriginProjectParser::supportedExtensions());
 #endif
 		break;
 	}
 
 	lastDir = conf.readEntry(lastDirConfEntryName, "");
 	QString path = QFileDialog::getOpenFileName(this, title, lastDir, supportedFormats);
 	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 != lastDir)
 			conf.writeEntry(lastDirConfEntryName, newDir);
 	}
 
 	ui.leFileName->setText(path);
 	refreshPreview();
 }
 
 void ImportProjectDialog::fileNameChanged(const QString& name) {
 	QString fileName = name;
 #ifndef HAVE_WINDOWS
 	// make relative path
 	if ( !fileName.isEmpty() && fileName.at(0) != 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;}");
 
 	if (!fileExists) {
 		//file doesn't exist -> delete the content preview that is still potentially
 		//available from the previously selected file
 		ui.tvPreview->setModel(nullptr);
 		m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 		return;
 	}
 
 	refreshPreview();
 }
 
 void ImportProjectDialog::newFolder() {
 	QString path = ui.leFileName->text();
 	QString name = path.right( path.length()-path.lastIndexOf(QDir::separator())-1 );
 
 	bool ok;
 	QInputDialog* dlg = new QInputDialog(this);
 	name = dlg->getText(this, i18n("Add new folder"), i18n("Folder name:"), QLineEdit::Normal, name, &ok);
 	if (ok) {
-		auto folder = new Folder(name);
+		auto* folder = new Folder(name);
 		m_mainWin->addAspectToProject(folder);
 		m_cbAddTo->setCurrentModelIndex(m_mainWin->model()->modelIndexOfAspect(folder));
 	}
 
 	delete dlg;
 }
diff --git a/src/kdefrontend/datasources/ImportSQLDatabaseDialog.cpp b/src/kdefrontend/datasources/ImportSQLDatabaseDialog.cpp
index 6b84dccbc..82998eedc 100644
--- a/src/kdefrontend/datasources/ImportSQLDatabaseDialog.cpp
+++ b/src/kdefrontend/datasources/ImportSQLDatabaseDialog.cpp
@@ -1,176 +1,176 @@
 /***************************************************************************
     File                 : ImportSQLDatabaseDialog.cpp
     Project              : LabPlot
     Description          : import SQL dataase dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2016 by Ankit Wagadre (wagadre.ankit@gmail.com)
     Copyright            : (C) 2016-2017 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ImportSQLDatabaseDialog.h"
 #include "ImportSQLDatabaseWidget.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/lib/macros.h"
 #include "kdefrontend/MainWin.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/matrix/Matrix.h"
 #include "backend/core/Workbook.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QDialogButtonBox>
 #include <QProgressBar>
 #include <QStatusBar>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 /*!
     \class ImportSQLDatabaseDialog
     \brief Dialog for importing data from a SQL database. Embeds \c ImportSQLDatabaseWidget and provides the standard buttons.
 
 	\ingroup kdefrontend
  */
 ImportSQLDatabaseDialog::ImportSQLDatabaseDialog(MainWin* parent) : ImportDialog(parent),
 	importSQLDatabaseWidget(new ImportSQLDatabaseWidget(this)) {
 
 	vLayout->addWidget(importSQLDatabaseWidget);
 
 	setWindowTitle(i18nc("@title:window", "Import Data to Spreadsheet or Matrix"));
 	setWindowIcon(QIcon::fromTheme("document-import-database"));
 	setModel();
 
 	//dialog buttons
 	QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 	okButton = buttonBox->button(QDialogButtonBox::Ok);
 	okButton->setEnabled(false); //ok is only available if a valid container was selected
 	vLayout->addWidget(buttonBox);
 
 	//Signals/Slots
 	connect(importSQLDatabaseWidget, &ImportSQLDatabaseWidget::stateChanged, this, &ImportSQLDatabaseDialog::checkOkButton);
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
 	connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
 
 	QTimer::singleShot(0, this, &ImportSQLDatabaseDialog::loadSettings);
 }
 
 void ImportSQLDatabaseDialog::loadSettings() {
 	//restore saved settings
 	QApplication::processEvents(QEventLoop::AllEvents, 0);
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportSQLDatabaseDialog");
 	KWindowConfig::restoreWindowSize(windowHandle(), conf);
 }
 
 ImportSQLDatabaseDialog::~ImportSQLDatabaseDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportSQLDatabaseDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void ImportSQLDatabaseDialog::importTo(QStatusBar* statusBar) const {
 	DEBUG("ImportSQLDatabaseDialog::import()");
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(cbAddTo->currentModelIndex().internalPointer());
 	if (!aspect) {
 		DEBUG("ERROR: No aspect available!");
 		return;
 	}
 
 	const auto mode = AbstractFileFilter::ImportMode(cbPosition->currentIndex());
 
 	//show a progress bar in the status bar
-	auto progressBar = new QProgressBar();
+	auto* progressBar = new QProgressBar();
 	progressBar->setMinimum(0);
 	progressBar->setMaximum(100);
 	connect(importSQLDatabaseWidget, &ImportSQLDatabaseWidget::completed, progressBar, &QProgressBar::setValue);
 
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 
 	WAIT_CURSOR;
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 
 	QTime timer;
 	timer.start();
 	if (aspect->inherits("Matrix")) {
-		auto matrix = qobject_cast<Matrix*>(aspect);
+		auto* matrix = qobject_cast<Matrix*>(aspect);
 		importSQLDatabaseWidget->read(matrix, mode);
 	} else if (aspect->inherits("Spreadsheet")) {
-		auto spreadsheet = qobject_cast<Spreadsheet*>(aspect);
+		auto* spreadsheet = qobject_cast<Spreadsheet*>(aspect);
 		importSQLDatabaseWidget->read(spreadsheet, mode);
 	} else if (aspect->inherits("Workbook")) {
 		// use active spreadsheet or matrix (only if numeric data is going to be imported) if present,
 		// create a new spreadsheet in the selected workbook otherwise
-		auto workbook = qobject_cast<Workbook*>(aspect);
+		auto* workbook = qobject_cast<Workbook*>(aspect);
 		Spreadsheet* spreadsheet = workbook->currentSpreadsheet();
 		Matrix* matrix = workbook->currentMatrix();
 		if (spreadsheet)
 			importSQLDatabaseWidget->read(spreadsheet, mode);
 		else if (matrix && importSQLDatabaseWidget->isNumericData())
 			importSQLDatabaseWidget->read(matrix, mode);
 		else {
 			spreadsheet = new Spreadsheet(i18n("Spreadsheet"));
 			workbook->addChild(spreadsheet);
 			importSQLDatabaseWidget->read(spreadsheet, mode);
 		}
 	}
 	statusBar->showMessage( i18n("Data imported in %1 seconds.", (float)timer.elapsed()/1000) );
 
 	RESET_CURSOR;
 	statusBar->removeWidget(progressBar);
 }
 
 QString ImportSQLDatabaseDialog::selectedObject() const {
 	return importSQLDatabaseWidget->selectedTable();
 }
 
 void ImportSQLDatabaseDialog::checkOkButton() {
 	DEBUG("ImportSQLDatabaseDialog::checkOkButton()");
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(cbAddTo->currentModelIndex().internalPointer());
 	if (!aspect) {
 		okButton->setEnabled(false);
 		okButton->setToolTip(i18n("Select a data container where the data has to be imported into."));
 		cbPosition->setEnabled(false);
 		return;
 	}
 
 	//check whether a valid connection and an object to import were selected
 	if (!importSQLDatabaseWidget->isValid()) {
 		okButton->setEnabled(false);
 		okButton->setToolTip(i18n("Select a valid database object (table or query result set) that has to be imported."));
 		cbPosition->setEnabled(false);
 		return;
 	}
 
 	//for matrix containers allow to import only numerical data
 	if (dynamic_cast<const Matrix*>(aspect) && !importSQLDatabaseWidget->isNumericData()) {
 		okButton->setEnabled(false);
 		okButton->setToolTip(i18n("Cannot import into a matrix since the data contains non-numerical data."));
 		cbPosition->setEnabled(false);
 		return;
 	}
 
 	okButton->setEnabled(true);
 	okButton->setToolTip(i18n("Close the dialog and import the data."));
 	cbPosition->setEnabled(true);
 }
diff --git a/src/kdefrontend/datasources/JsonOptionsWidget.cpp b/src/kdefrontend/datasources/JsonOptionsWidget.cpp
index 1ace2c495..dee8c078f 100644
--- a/src/kdefrontend/datasources/JsonOptionsWidget.cpp
+++ b/src/kdefrontend/datasources/JsonOptionsWidget.cpp
@@ -1,195 +1,195 @@
 /***************************************************************************
     File                 : JsonOptionsWidget.cpp
     Project              : LabPlot
     Description          : Widget providing options for the import of json data.
     --------------------------------------------------------------------
     --------------------------------------------------------------------
     Copyright            : (C) 2018 Andrey Cygankov (craftplace.ms@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 "JsonOptionsWidget.h"
 #include "ImportFileWidget.h"
 #include "backend/datasources/filters/QJsonModel.h"
 #include "backend/datasources/filters/AbstractFileFilter.h"
 #include "backend/datasources/filters/JsonFilter.h"
 
 #include <KLocalizedString>
 #include <KFilterDev>
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 /*!
 \class JsonOptionsWidget
 \brief Widget providing options for the import of json data
 
 \ingroup kdefrontend
 */
 JsonOptionsWidget::JsonOptionsWidget(QWidget* parent, ImportFileWidget* fileWidget) : QWidget(parent),
 	m_fileWidget(fileWidget),
 	m_model(new QJsonModel()) {
 
 	ui.setupUi(parent);
 
 	ui.cbNumberFormat->addItems(AbstractFileFilter::numberFormats());
 	ui.cbDateTimeFormat->addItems(AbstractColumn::dateTimeFormats());
 
 	setTooltips();
 }
 
 void JsonOptionsWidget::applyFilterSettings(JsonFilter* filter, const QModelIndex& index) const {
 	Q_ASSERT(filter);
 
 	filter->setModelRows(getIndexRows(index));
 	filter->setNumberFormat( QLocale::Language(ui.cbNumberFormat->currentIndex()));
 	filter->setDateTimeFormat(ui.cbDateTimeFormat->currentText());
 	filter->setCreateIndexEnabled(ui.chbCreateIndex->isChecked());
 	filter->setNaNValueToZero(ui.chbConvertNaNToZero->isChecked());
 	filter->setImportObjectNames(ui.chbImportObjectNames->isChecked());
 
 	//TODO: change this after implementation other row types
 	filter->setDataRowType(QJsonValue::Array);
 	if (!index.isValid()) return;
-	auto item = static_cast<QJsonTreeItem*>(index.internalPointer());
+	auto* item = static_cast<QJsonTreeItem*>(index.internalPointer());
 	if (item->childCount() < 1) return;
 	filter->setDataRowType(item->child(0)->type());
 }
 
 void JsonOptionsWidget::clearModel() {
 	m_model->clear();
 }
 
 void JsonOptionsWidget::loadSettings() const {
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportJson");
 
 	ui.cbNumberFormat->setCurrentIndex(conf.readEntry("NumberFormat", (int)QLocale::AnyLanguage));
 	ui.cbDateTimeFormat->setCurrentItem(conf.readEntry("DateTimeFormat", "yyyy-MM-dd hh:mm:ss.zzz"));
 	ui.chbCreateIndex->setChecked(conf.readEntry("CreateIndex", false));
 	ui.chbConvertNaNToZero->setChecked(conf.readEntry("ConvertNaNToZero", false));
 	ui.chbImportObjectNames->setChecked(conf.readEntry("ParseRowsName", false));
 }
 
 void JsonOptionsWidget::saveSettings() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "ImportJson");
 
 	conf.writeEntry("NumberFormat", ui.cbNumberFormat->currentIndex());
 	conf.writeEntry("DateTimeFormat", ui.cbDateTimeFormat->currentText());
 	conf.writeEntry("CreateIndex", ui.chbCreateIndex->isChecked());
 	conf.writeEntry("ConvertNaNToZero", ui.chbConvertNaNToZero->isChecked());
 	conf.writeEntry("ParseRowsName", ui.chbImportObjectNames->isChecked());
 }
 
 void JsonOptionsWidget::loadDocument(QString filename) {
 	if (m_filename == filename) return;
 	else
 		m_filename = filename;
 
 	KFilterDev device(m_filename);
 	if (!device.open(QIODevice::ReadOnly))
 		return;
 
 	if (device.atEnd() && !device.isSequential()) // empty file
 		return;
 	if (!m_model->loadJson(device.readAll()))
 		m_model->clear();
 }
 
 QJsonModel* JsonOptionsWidget::model() {
 	return m_model;
 }
 
 void JsonOptionsWidget::setTooltips() {
 	const QString textNumberFormatShort = i18n("This option determines how the imported strings have to be converted to numbers.");
 	const QString textNumberFormat = textNumberFormatShort + "<br><br>" + i18n(
 			"For 'C Format', a period is used for the decimal point character and comma is used for the thousands group separator. "
 			"Valid number representations are:"
 			"<ul>"
 			"<li>1234.56</li>"
 			"<li>1,234.56</li>"
 			"<li>etc.</li>"
 			"</ul>"
 			"When using 'System locale', the system settings will be used. "
 			"E.g., for the German local the valid number representations are:"
 			"<ul>"
 			"<li>1234,56</li>"
 			"<li>1.234,56</li>"
 			"<li>etc.</li>"
 			"</ul>"
 	);
 
 	ui.lNumberFormat->setToolTip(textNumberFormatShort);
 	ui.lNumberFormat->setWhatsThis(textNumberFormat);
 	ui.cbNumberFormat->setToolTip(textNumberFormatShort);
 	ui.cbNumberFormat->setWhatsThis(textNumberFormat);
 
 	const QString textDateTimeFormatShort = i18n("This option determines how the imported strings have to be converted to calendar date, i.e. year, month, and day numbers in the Gregorian calendar and to time.");
 	const QString textDateTimeFormat = textDateTimeFormatShort + "<br><br>" + i18n(
 			"Expressions that may be used for the date part of format string:"
 			"<table>"
 			"<tr><td>d</td><td>the day as number without a leading zero (1 to 31).</td></tr>"
 			"<tr><td>dd</td><td>the day as number with a leading zero (01 to 31).</td></tr>"
 			"<tr><td>ddd</td><td>the abbreviated localized day name (e.g. 'Mon' to 'Sun'). Uses the system locale to localize the name.</td></tr>"
 			"<tr><td>dddd</td><td>the long localized day name (e.g. 'Monday' to 'Sunday'). Uses the system locale to localize the name.</td></tr>"
 			"<tr><td>M</td><td>the month as number without a leading zero (1 to 12).</td></tr>"
 			"<tr><td>MM</td><td>the month as number with a leading zero (01 to 12).</td></tr>"
 			"<tr><td>MMM</td><td>the abbreviated localized month name (e.g. 'Jan' to 'Dec'). Uses the system locale to localize the name.</td></tr>"
 			"<tr><td>MMMM</td><td>the long localized month name (e.g. 'January' to 'December'). Uses the system locale to localize the name.</td></tr>"
 			"<tr><td>yy</td><td>the year as two digit number (00 to 99).</td></tr>"
 			"<tr><td>yyyy</td><td>the year as four digit number. If the year is negative, a minus sign is prepended in addition.</td></tr>"
 			"</table><br><br>"
 			"Expressions that may be used for the time part of the format string:"
 			"<table>"
 			"<tr><td>h</td><td>the hour without a leading zero (0 to 23 or 1 to 12 if AM/PM display)</td></tr>"
 			"<tr><td>hh</td><td>the hour with a leading zero (00 to 23 or 01 to 12 if AM/PM display)</td></tr>"
 			"<tr><td>H</td><td>the hour without a leading zero (0 to 23, even with AM/PM display)</td></tr>"
 			"<tr><td>HH</td><td>the hour with a leading zero (00 to 23, even with AM/PM display)</td></tr>"
 			"<tr><td>m</td><td>the minute without a leading zero (0 to 59)</td></tr>"
 			"<tr><td>mm</td><td>the minute with a leading zero (00 to 59)</td></tr>"
 			"<tr><td>s</td><td>the second without a leading zero (0 to 59)</td></tr>"
 			"<tr><td>ss</td><td>the second with a leading zero (00 to 59)</td></tr>"
 			"<tr><td>z</td><td>the milliseconds without leading zeroes (0 to 999)</td></tr>"
 			"<tr><td>zzz</td><td>the milliseconds with leading zeroes (000 to 999)</td></tr>"
 			"<tr><td>AP or A</td><td>interpret as an AM/PM time. AP must be either 'AM' or 'PM'.</td></tr>"
 			"<tr><td>ap or a</td><td>Interpret as an AM/PM time. ap must be either 'am' or 'pm'.</td></tr>"
 			"</table><br><br>"
 			"Examples are:"
 			"<table>"
 			"<tr><td>dd.MM.yyyy</td><td>20.07.1969</td></tr>"
 			"<tr><td>ddd MMMM d yy</td><td>Sun July 20 69</td></tr>"
 			"<tr><td>'The day is' dddd</td><td>The day is Sunday</td></tr>"
 			"</table>");
 
 	ui.lDateTimeFormat->setToolTip(textDateTimeFormatShort);
 	ui.lDateTimeFormat->setWhatsThis(textDateTimeFormat);
 	ui.cbDateTimeFormat->setToolTip(textDateTimeFormatShort);
 	ui.cbDateTimeFormat->setWhatsThis(textDateTimeFormat);
 }
 
 QVector<int> JsonOptionsWidget::getIndexRows(const QModelIndex &index) const {
 	QVector<int> rows;
 	QModelIndex current = index;
 	while(current.isValid()){
 		rows.prepend(current.row());
 		current = current.parent();
 	}
 	return rows;
 }
diff --git a/src/kdefrontend/datasources/NetCDFOptionsWidget.cpp b/src/kdefrontend/datasources/NetCDFOptionsWidget.cpp
index 64422bd5a..48cc87896 100644
--- a/src/kdefrontend/datasources/NetCDFOptionsWidget.cpp
+++ b/src/kdefrontend/datasources/NetCDFOptionsWidget.cpp
@@ -1,127 +1,127 @@
 /***************************************************************************
 File                 : NetCDFOptionsWidget.cpp
 Project              : LabPlot
 Description          : widget providing options for the import of NetCDF data
 --------------------------------------------------------------------
 Copyright            : (C) 2015-2017 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 "NetCDFOptionsWidget.h"
 #include "ImportFileWidget.h"
 #include "backend/datasources/filters/NetCDFFilter.h"
 #include "backend/lib/macros.h"
 
  /*!
 	\class NetCDFOptionsWidget
 	\brief Widget providing options for the import of NetCDF data
 
 	\ingroup kdefrontend
  */
 NetCDFOptionsWidget::NetCDFOptionsWidget(QWidget* parent, ImportFileWidget* fileWidget)
 		: QWidget(parent), m_fileWidget(fileWidget) {
 	ui.setupUi(parent);
 
 	QStringList headers;
 	headers << i18n("Name") << i18n("Type") << i18n("Properties") << i18n("Values");
 	ui.twContent->setHeaderLabels(headers);
 	// type column is hidden
 	ui.twContent->hideColumn(1);
 	ui.twContent->setSelectionMode(QAbstractItemView::ExtendedSelection);
 	ui.twContent->setAlternatingRowColors(true);
 	ui.twContent->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
 	ui.twPreview->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
 	ui.bRefreshPreview->setIcon( QIcon::fromTheme("view-refresh") );
 
 	connect( ui.twContent, SIGNAL(itemSelectionChanged()), SLOT(netcdfTreeWidgetSelectionChanged()) );
 	connect( ui.bRefreshPreview, SIGNAL(clicked()), fileWidget, SLOT(refreshPreview()) );
 }
 
 void NetCDFOptionsWidget::clear() {
 	ui.twContent->clear();
 	ui.twPreview->clear();
 }
 
 void NetCDFOptionsWidget::updateContent(NetCDFFilter *filter, const QString& fileName) {
 	ui.twContent->clear();
 
 	QTreeWidgetItem *rootItem = ui.twContent->invisibleRootItem();
 	filter->parse(fileName, rootItem);
 	ui.twContent->insertTopLevelItem(0, rootItem);
 	ui.twContent->expandAll();
 	ui.twContent->resizeColumnToContents(0);
 	ui.twContent->resizeColumnToContents(2);
 }
 
 /*!
 	updates the selected var name of a NetCDF file when the tree widget item is selected
 */
 void NetCDFOptionsWidget::netcdfTreeWidgetSelectionChanged() {
 	DEBUG("netcdfTreeWidgetSelectionChanged()");
 	QDEBUG("SELECTED ITEMS =" << ui.twContent->selectedItems());
 
 	if (ui.twContent->selectedItems().isEmpty())
 		return;
 
 	QTreeWidgetItem* item = ui.twContent->selectedItems().first();
 	if (item->data(1, Qt::DisplayRole).toString() == "variable")
 		m_fileWidget->refreshPreview();
 	else if (item->data(1, Qt::DisplayRole).toString().contains("attribute")) {
 		// reads attributes (only for preview)
-		auto filter = (NetCDFFilter *)m_fileWidget->currentFileFilter();
+		auto* filter = (NetCDFFilter*)m_fileWidget->currentFileFilter();
 		QString fileName = m_fileWidget->ui.leFileName->text();
 		QString name = item->data(0, Qt::DisplayRole).toString();
 		QString varName = item->data(1, Qt::DisplayRole).toString().split(' ')[0];
 		QDEBUG("name =" << name << "varName =" << varName);
 
 		QString importedText = filter->readAttribute(fileName, name, varName);
 		DEBUG("importedText =" << importedText.toStdString());
 
 		QStringList lineStrings = importedText.split('\n');
 		int rows = lineStrings.size();
 		ui.twPreview->setRowCount(rows);
 		ui.twPreview->setColumnCount(0);
 		for (int i = 0; i < rows; ++i) {
 			QStringList lineString = lineStrings[i].split(' ');
 			int cols = lineString.size();
 			if (ui.twPreview->columnCount() < cols)
 				ui.twPreview->setColumnCount(cols);
 
 			for (int j = 0; j < cols; ++j) {
-				auto item = new QTableWidgetItem();
+				auto* item = new QTableWidgetItem();
 				item->setText(lineString[j]);
 				ui.twPreview->setItem(i, j, item);
 			}
 		}
 	} else
 		DEBUG("non showable object selected in NetCDF tree widget");
 }
 
 /*!
 	return list of selected NetCDF item names
 */
 const QStringList NetCDFOptionsWidget::selectedNetCDFNames() const {
 	QStringList names;
-	for (auto* item: ui.twContent->selectedItems())
+	for (auto* item : ui.twContent->selectedItems())
 		names << item->text(0);
 
 	return names;
 }
diff --git a/src/kdefrontend/dockwidgets/AxisDock.cpp b/src/kdefrontend/dockwidgets/AxisDock.cpp
index 47309aa75..0882e0419 100644
--- a/src/kdefrontend/dockwidgets/AxisDock.cpp
+++ b/src/kdefrontend/dockwidgets/AxisDock.cpp
@@ -1,1974 +1,1974 @@
 /***************************************************************************
     File                 : AxisDock.cpp
     Project              : LabPlot
     Description          : axes widget class
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2012-2013 Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "AxisDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/GuiTools.h"
 #include "kdefrontend/TemplateHandler.h"
 #include "kdefrontend/widgets/LabelWidget.h"
 
 #include <QTimer>
 #include <QDir>
 #include <QPainter>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 /*!
  \class AxisDock
  \brief Provides a widget for editing the properties of the axes currently selected in the project explorer.
 
  \ingroup kdefrontend
 */
 
 AxisDock::AxisDock(QWidget* parent):QWidget(parent), m_axis(nullptr), m_aspectTreeModel(nullptr), m_dataChanged(false), m_initializing(false) {
 	ui.setupUi(this);
 
 	//"Title"-tab
-	auto hboxLayout = new QHBoxLayout(ui.tabTitle);
+	auto* hboxLayout = new QHBoxLayout(ui.tabTitle);
 	labelWidget = new LabelWidget(ui.tabTitle);
 	labelWidget->setFixedLabelMode(true);
 	hboxLayout->addWidget(labelWidget);
 	hboxLayout->setContentsMargins(2,2,2,2);
 	hboxLayout->setSpacing(2);
 
 	//"Ticks"-tab
-	auto layout = static_cast<QGridLayout*>(ui.tabTicks->layout());
+	auto* layout = static_cast<QGridLayout*>(ui.tabTicks->layout());
 	cbMajorTicksColumn = new TreeViewComboBox(ui.tabTicks);
 	layout->addWidget(cbMajorTicksColumn, 5, 2);
 
 	cbMinorTicksColumn = new TreeViewComboBox(ui.tabTicks);
 	layout->addWidget(cbMinorTicksColumn, 18, 2);
 
 	//adjust layouts in the tabs
-	for (int i=0; i<ui.tabWidget->count(); ++i) {
+	for (int i = 0; i < ui.tabWidget->count(); ++i) {
 		layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
 		if (!layout)
 			continue;
 
 		layout->setContentsMargins(2,2,2,2);
 		layout->setHorizontalSpacing(2);
 		layout->setVerticalSpacing(2);
 	}
 
 	//**********************************  Slots **********************************************
 
 	//"General"-tab
 	connect(ui.leName, &QLineEdit::textChanged, this, &AxisDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &AxisDock::commentChanged);
 	connect( ui.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 
 	connect( ui.cbOrientation, SIGNAL(currentIndexChanged(int)), this, SLOT(orientationChanged(int)) );
 	connect( ui.cbPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(positionChanged(int)) );
 	connect( ui.lePosition, SIGNAL(textChanged(QString)), this, SLOT(positionChanged()) );
 	connect( ui.cbScale, SIGNAL(currentIndexChanged(int)), this, SLOT(scaleChanged(int)) );
 
 	connect( ui.chkAutoScale, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)) );
 	connect( ui.leStart, SIGNAL(textChanged(QString)), this, SLOT(startChanged()) );
 	connect( ui.leEnd, SIGNAL(textChanged(QString)), this, SLOT(endChanged()) );
 	connect(ui.dateTimeEditStart, &QDateTimeEdit::dateTimeChanged, this, &AxisDock::startDateTimeChanged);
 	connect(ui.dateTimeEditEnd, &QDateTimeEdit::dateTimeChanged, this, &AxisDock::endDateTimeChanged);
 	connect( ui.leZeroOffset, SIGNAL(textChanged(QString)), this, SLOT(zeroOffsetChanged()) );
 	connect( ui.leScalingFactor, SIGNAL(textChanged(QString)), this, SLOT(scalingFactorChanged()) );
 
 	//"Line"-tab
 	connect( ui.cbLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(lineStyleChanged(int)) );
 	connect( ui.kcbLineColor, SIGNAL(changed(QColor)), this, SLOT(lineColorChanged(QColor)) );
 	connect( ui.sbLineWidth, SIGNAL(valueChanged(double)), this, SLOT(lineWidthChanged(double)) );
 	connect( ui.sbLineOpacity, SIGNAL(valueChanged(int)), this, SLOT(lineOpacityChanged(int)) );
 	connect( ui.cbArrowPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(arrowPositionChanged(int)) );
 	connect( ui.cbArrowType, SIGNAL(currentIndexChanged(int)), this, SLOT(arrowTypeChanged(int)) );
 	connect( ui.sbArrowSize, SIGNAL(valueChanged(int)), this, SLOT(arrowSizeChanged(int)) );
 
 	//"Major ticks"-tab
 	connect( ui.cbMajorTicksDirection, SIGNAL(currentIndexChanged(int)), this, SLOT(majorTicksDirectionChanged(int)) );
 	connect( ui.cbMajorTicksType, SIGNAL(currentIndexChanged(int)), this, SLOT(majorTicksTypeChanged(int)) );
 	connect( ui.sbMajorTicksNumber, SIGNAL(valueChanged(int)), this, SLOT(majorTicksNumberChanged(int)) );
 	connect( ui.leMajorTicksIncrement, SIGNAL(textChanged(QString)), this, SLOT(majorTicksIncrementChanged()) );
 	connect( cbMajorTicksColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(majorTicksColumnChanged(QModelIndex)) );
 	connect( ui.cbMajorTicksLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(majorTicksLineStyleChanged(int)) );
 	connect( ui.kcbMajorTicksColor, SIGNAL(changed(QColor)), this, SLOT(majorTicksColorChanged(QColor)) );
 	connect( ui.sbMajorTicksWidth, SIGNAL(valueChanged(double)), this, SLOT(majorTicksWidthChanged(double)) );
 	connect( ui.sbMajorTicksLength, SIGNAL(valueChanged(double)), this, SLOT(majorTicksLengthChanged(double)) );
 	connect( ui.sbMajorTicksOpacity, SIGNAL(valueChanged(int)), this, SLOT(majorTicksOpacityChanged(int)) );
 
 	//"Minor ticks"-tab
 	connect( ui.cbMinorTicksDirection, SIGNAL(currentIndexChanged(int)), this, SLOT(minorTicksDirectionChanged(int)) );
 	connect( ui.cbMinorTicksType, SIGNAL(currentIndexChanged(int)), this, SLOT(minorTicksTypeChanged(int)) );
 	connect( ui.sbMinorTicksNumber, SIGNAL(valueChanged(int)), this, SLOT(minorTicksNumberChanged(int)) );
 	connect( ui.leMinorTicksIncrement, SIGNAL(textChanged(QString)), this, SLOT(minorTicksIncrementChanged()) );
 	connect( cbMinorTicksColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(minorTicksColumnChanged(QModelIndex)) );
 	connect( ui.cbMinorTicksLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(minorTicksLineStyleChanged(int)) );
 	connect( ui.kcbMinorTicksColor, SIGNAL(changed(QColor)), this, SLOT(minorTicksColorChanged(QColor)) );
 	connect( ui.sbMinorTicksWidth, SIGNAL(valueChanged(double)), this, SLOT(minorTicksWidthChanged(double)) );
 	connect( ui.sbMinorTicksLength, SIGNAL(valueChanged(double)), this, SLOT(minorTicksLengthChanged(double)) );
 	connect( ui.sbMinorTicksOpacity, SIGNAL(valueChanged(int)), this, SLOT(minorTicksOpacityChanged(int)) );
 
 	//"Extra ticks"-tab
 
 	//"Tick labels"-tab
 	connect( ui.cbLabelsFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(labelsFormatChanged(int)) );
 	connect( ui.sbLabelsPrecision, SIGNAL(valueChanged(int)), this, SLOT(labelsPrecisionChanged(int)) );
 	connect( ui.chkLabelsAutoPrecision, SIGNAL(stateChanged(int)), this, SLOT(labelsAutoPrecisionChanged(int)) );
 	connect(ui.cbLabelsDateTimeFormat, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &AxisDock::labelsDateTimeFormatChanged);
 	connect( ui.cbLabelsPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(labelsPositionChanged(int)) );
 	connect( ui.sbLabelsOffset, SIGNAL(valueChanged(double)), this, SLOT(labelsOffsetChanged(double)) );
 	connect( ui.sbLabelsRotation, SIGNAL(valueChanged(int)), this, SLOT(labelsRotationChanged(int)) );
 	connect( ui.kfrLabelsFont, SIGNAL(fontSelected(QFont)), this, SLOT(labelsFontChanged(QFont)) );
 	connect( ui.kcbLabelsFontColor, SIGNAL(changed(QColor)), this, SLOT(labelsFontColorChanged(QColor)) );
 	connect( ui.leLabelsPrefix, SIGNAL(textChanged(QString)), this, SLOT(labelsPrefixChanged()) );
 	connect( ui.leLabelsSuffix, SIGNAL(textChanged(QString)), this, SLOT(labelsSuffixChanged()) );
 	connect( ui.sbLabelsOpacity, SIGNAL(valueChanged(int)), this, SLOT(labelsOpacityChanged(int)) );
 
 	//"Grid"-tab
 	connect( ui.cbMajorGridStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(majorGridStyleChanged(int)) );
 	connect( ui.kcbMajorGridColor, SIGNAL(changed(QColor)), this, SLOT(majorGridColorChanged(QColor)) );
 	connect( ui.sbMajorGridWidth, SIGNAL(valueChanged(double)), this, SLOT(majorGridWidthChanged(double)) );
 	connect( ui.sbMajorGridOpacity, SIGNAL(valueChanged(int)), this, SLOT(majorGridOpacityChanged(int)) );
 
 	connect( ui.cbMinorGridStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(minorGridStyleChanged(int)) );
 	connect( ui.kcbMinorGridColor, SIGNAL(changed(QColor)), this, SLOT(minorGridColorChanged(QColor)) );
 	connect( ui.sbMinorGridWidth, SIGNAL(valueChanged(double)), this, SLOT(minorGridWidthChanged(double)) );
 	connect( ui.sbMinorGridOpacity, SIGNAL(valueChanged(int)), this, SLOT(minorGridOpacityChanged(int)) );
 
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Axis);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Axis);
 	ui.verticalLayout->addWidget(templateHandler);
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 
 	init();
 }
 
 AxisDock::~AxisDock() {
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 }
 
 void AxisDock::init() {
 	m_initializing = true;
 
 	//Validators
 	ui.lePosition->setValidator( new QDoubleValidator(ui.lePosition) );
 	ui.leStart->setValidator( new QDoubleValidator(ui.leStart) );
 	ui.leEnd->setValidator( new QDoubleValidator(ui.leEnd) );
 	ui.leZeroOffset->setValidator( new QDoubleValidator(ui.leZeroOffset) );
 	ui.leScalingFactor->setValidator( new QDoubleValidator(ui.leScalingFactor) );
 
 	ui.leMajorTicksIncrement->setValidator( new QDoubleValidator(ui.leMajorTicksIncrement) );
 	ui.leMinorTicksIncrement->setValidator( new QDoubleValidator(ui.leMinorTicksIncrement) );
 
 	//TODO move this stuff to retranslateUI()
 	ui.cbPosition->addItem(i18n("Top"));
 	ui.cbPosition->addItem(i18n("Bottom"));
 	ui.cbPosition->addItem(i18n("Centered"));
 	ui.cbPosition->addItem(i18n("Custom"));
 
 	ui.cbScale->addItem( i18n("Linear") );
 	ui.cbScale->addItem( QLatin1String("log(x)") );
 	ui.cbScale->addItem( QLatin1String("log2(x)") );
 	ui.cbScale->addItem( QLatin1String("ln(x)") );
 	ui.cbScale->addItem( QLatin1String("sqrt(x)") );
 	ui.cbScale->addItem( QLatin1String("x^2") );
 
 	ui.cbOrientation->addItem( i18n("Horizontal") );
 	ui.cbOrientation->addItem( i18n("Vertical") );
 
 	//Arrows
 	ui.cbArrowType->addItem( i18n("No arrow") );
 	ui.cbArrowType->addItem( i18n("Simple, Small") );
 	ui.cbArrowType->addItem( i18n("Simple, Big") );
 	ui.cbArrowType->addItem( i18n("Filled, Small") );
 	ui.cbArrowType->addItem( i18n("Filled, Big") );
 	ui.cbArrowType->addItem( i18n("Semi-filled, Small") );
 	ui.cbArrowType->addItem( i18n("Semi-filled, Big") );
 
 	QPainter pa;
 	pa.setPen( QPen(Qt::SolidPattern, 0) );
 	QPixmap pm(20, 20);
 	ui.cbArrowType->setIconSize( QSize(20,20) );
 
 	//no arrow
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10);
 	pa.end();
 	ui.cbArrowType->setItemIcon(0, pm);
 
 	//simple, small
 	float cos_phi = cos(3.14159/6);
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawLine(3,10,17,10);
 	pa.drawLine(17,10, 10, 10-5*cos_phi);
 	pa.drawLine(17,10, 10, 10+5*cos_phi);
 	pa.end();
 	ui.cbArrowType->setItemIcon(1, pm);
 
 	//simple, big
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawLine(3,10,17,10);
 	pa.drawLine(17,10, 10, 10-10*cos_phi);
 	pa.drawLine(17,10, 10, 10+10*cos_phi);
 	pa.end();
 	ui.cbArrowType->setItemIcon(2, pm);
 
 	//filled, small
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10);
 	QPointF points3[3] = {QPointF(17, 10), QPointF(10, 10-4*cos_phi), QPointF(10, 10+4*cos_phi) };
 	pa.drawPolygon(points3, 3);
 	pa.end();
 	ui.cbArrowType->setItemIcon(3, pm);
 
 	//filled, big
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10);
 	QPointF points4[3] = {QPointF(17, 10), QPointF(10, 10-10*cos_phi), QPointF(10, 10+10*cos_phi) };
 	pa.drawPolygon(points4, 3);
 	pa.end();
 	ui.cbArrowType->setItemIcon(4, pm);
 
 	//semi-filled, small
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10);
 	QPointF points5[4] = {QPointF(17, 10), QPointF(10, 10-4*cos_phi), QPointF(13, 10), QPointF(10, 10+4*cos_phi) };
 	pa.drawPolygon(points5, 4);
 	pa.end();
 	ui.cbArrowType->setItemIcon(5, pm);
 
 	//semi-filled, big
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10);
 	QPointF points6[4] = {QPointF(17, 10), QPointF(10, 10-10*cos_phi), QPointF(13, 10), QPointF(10, 10+10*cos_phi) };
 	pa.drawPolygon(points6, 4);
 	pa.end();
 	ui.cbArrowType->setItemIcon(6, pm);
 
 	ui.cbArrowPosition->addItem( i18n("Left") );
 	ui.cbArrowPosition->addItem( i18n("Right") );
 	ui.cbArrowPosition->addItem( i18n("Both") );
 
 	ui.cbMajorTicksDirection->addItem( i18n("None") );
 	ui.cbMajorTicksDirection->addItem( i18n("In") );
 	ui.cbMajorTicksDirection->addItem( i18n("Out") );
 	ui.cbMajorTicksDirection->addItem( i18n("In and Out") );
 
 	ui.cbMajorTicksType->addItem( i18n("Number") );
 	ui.cbMajorTicksType->addItem( i18n("Increment") );
 	ui.cbMajorTicksType->addItem( i18n("Custom column") );
 
 	ui.cbMinorTicksDirection->addItem( i18n("None") );
 	ui.cbMinorTicksDirection->addItem( i18n("In") );
 	ui.cbMinorTicksDirection->addItem( i18n("Out") );
 	ui.cbMinorTicksDirection->addItem( i18n("In and Out") );
 
 	ui.cbMinorTicksType->addItem( i18n("Number") );
 	ui.cbMinorTicksType->addItem( i18n("Increment") );
 	ui.cbMinorTicksType->addItem( i18n("Custom column") );
 
 	GuiTools::updatePenStyles(ui.cbLineStyle, QColor(Qt::black));
 	GuiTools::updatePenStyles(ui.cbMajorTicksLineStyle, QColor(Qt::black));
 	GuiTools::updatePenStyles(ui.cbMinorTicksLineStyle, QColor(Qt::black));
 
 	//labels
 	ui.cbLabelsPosition->addItem(i18n("No labels"));
 	ui.cbLabelsPosition->addItem(i18n("Top"));
 	ui.cbLabelsPosition->addItem(i18n("Bottom"));
 
 	ui.cbLabelsFormat->addItem( i18n("Decimal notation") );
 	ui.cbLabelsFormat->addItem( i18n("Scientific notation") );
 	ui.cbLabelsFormat->addItem( i18n("Powers of 10") );
 	ui.cbLabelsFormat->addItem( i18n("Powers of 2") );
 	ui.cbLabelsFormat->addItem( i18n("Powers of e") );
 	ui.cbLabelsFormat->addItem( i18n("Multiples of π") );
 
 	ui.cbLabelsDateTimeFormat->addItems(AbstractColumn::dateTimeFormats());
 
 	m_initializing = false;
 }
 
 void AxisDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Spreadsheet"<<"FileDataSource"<<"Column";
 	cbMajorTicksColumn->setTopLevelClasses(list);
 	cbMinorTicksColumn->setTopLevelClasses(list);
 
 	list.clear();
 	list<<"Column";
 	m_aspectTreeModel->setSelectableAspects(list);
 
 	cbMajorTicksColumn->setModel(m_aspectTreeModel);
 	cbMinorTicksColumn->setModel(m_aspectTreeModel);
 }
 
 /*!
   sets the axes. The properties of the axes in the list \c list can be edited in this widget.
 */
 void AxisDock::setAxes(QList<Axis*> list) {
 	m_initializing = true;
 	m_axesList=list;
 	m_axis=list.first();
 	Q_ASSERT(m_axis != nullptr);
 	m_aspectTreeModel = new AspectTreeModel(m_axis->project());
 	this->setModel();
 
 	labelWidget->setAxes(list);
 
 	//if there are more then one axis in the list, disable the tab "general"
 	if (list.size() == 1) {
 		ui.lName->setEnabled(true);
 		ui.leName->setEnabled(true);
 		ui.lComment->setEnabled(true);
 		ui.leComment->setEnabled(true);
 		ui.leName->setText(m_axis->name());
 		ui.leComment->setText(m_axis->comment());
 		this->setModelIndexFromColumn(cbMajorTicksColumn, m_axis->majorTicksColumn());
 		this->setModelIndexFromColumn(cbMinorTicksColumn, m_axis->minorTicksColumn());
 	} else {
 		ui.lName->setEnabled(false);
 		ui.leName->setEnabled(false);
 		ui.lComment->setEnabled(false);
 		ui.leComment->setEnabled(false);
 		ui.leName->setText("");
 		ui.leComment->setText("");
 		cbMajorTicksColumn->setCurrentModelIndex(QModelIndex());
 		cbMinorTicksColumn->setCurrentModelIndex(QModelIndex());
 	}
 
 	//show the properties of the first axis
 	this->load();
 
 	// general
 	connect(m_axis, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),this, SLOT(axisDescriptionChanged(const AbstractAspect*)));
 	connect(m_axis, SIGNAL(orientationChanged(Axis::AxisOrientation)), this, SLOT(axisOrientationChanged(Axis::AxisOrientation)));
 	connect(m_axis, SIGNAL(positionChanged(Axis::AxisPosition)), this, SLOT(axisPositionChanged(Axis::AxisPosition)));
 	connect(m_axis, SIGNAL(scaleChanged(Axis::AxisScale)), this, SLOT(axisScaleChanged(Axis::AxisScale)));
 	connect(m_axis, SIGNAL(autoScaleChanged(bool)), this, SLOT(axisAutoScaleChanged(bool)));
 	connect(m_axis, SIGNAL(startChanged(double)), this, SLOT(axisStartChanged(double)));
 	connect(m_axis, SIGNAL(endChanged(double)), this, SLOT(axisEndChanged(double)));
 	connect(m_axis, SIGNAL(zeroOffsetChanged(qreal)), this, SLOT(axisZeroOffsetChanged(qreal)));
 	connect(m_axis, SIGNAL(scalingFactorChanged(qreal)), this, SLOT(axisScalingFactorChanged(qreal)));
 
 	// line
 	connect(m_axis, SIGNAL(linePenChanged(QPen)), this, SLOT(axisLinePenChanged(QPen)));
 	connect(m_axis, SIGNAL(lineOpacityChanged(qreal)), this, SLOT(axisLineOpacityChanged(qreal)));
 	connect(m_axis, SIGNAL(arrowTypeChanged(Axis::ArrowType)), this, SLOT(axisArrowTypeChanged(Axis::ArrowType)));
 	connect(m_axis, SIGNAL(arrowPositionChanged(Axis::ArrowPosition)), this, SLOT(axisArrowPositionChanged(Axis::ArrowPosition)));
 	connect(m_axis, SIGNAL(arrowSizeChanged(qreal)), this, SLOT(axisArrowSizeChanged(qreal)));
 
 	// ticks
 	connect(m_axis, SIGNAL(majorTicksDirectionChanged(Axis::TicksDirection)), this, SLOT(axisMajorTicksDirectionChanged(Axis::TicksDirection)));
 	connect(m_axis, SIGNAL(majorTicksTypeChanged(Axis::TicksType)), this, SLOT(axisMajorTicksTypeChanged(Axis::TicksType)));
 	connect(m_axis, SIGNAL(majorTicksNumberChanged(int)), this, SLOT(axisMajorTicksNumberChanged(int)));
 	connect(m_axis, SIGNAL(majorTicksIncrementChanged(qreal)), this, SLOT(axisMajorTicksIncrementChanged(qreal)));
 	connect(m_axis, SIGNAL(majorTicksPenChanged(QPen)), this, SLOT(axisMajorTicksPenChanged(QPen)));
 	connect(m_axis, SIGNAL(majorTicksLengthChanged(qreal)), this, SLOT(axisMajorTicksLengthChanged(qreal)));
 	connect(m_axis, SIGNAL(majorTicksOpacityChanged(qreal)), this, SLOT(axisMajorTicksOpacityChanged(qreal)));
 	connect(m_axis, SIGNAL(minorTicksDirectionChanged(Axis::TicksDirection)), this, SLOT(axisMinorTicksDirectionChanged(Axis::TicksDirection)));
 	connect(m_axis, SIGNAL(minorTicksTypeChanged(Axis::TicksType)), this, SLOT(axisMinorTicksTypeChanged(Axis::TicksType)));
 	connect(m_axis, SIGNAL(minorTicksNumberChanged(int)), this, SLOT(axisMinorTicksNumberChanged(int)));
 	connect(m_axis, SIGNAL(minorTicksIncrementChanged(qreal)), this, SLOT(axisMinorTicksIncrementChanged(qreal)));
 	connect(m_axis, SIGNAL(minorTicksPenChanged(QPen)), this, SLOT(axisMinorTicksPenChanged(QPen)));
 	connect(m_axis, SIGNAL(minorTicksLengthChanged(qreal)), this, SLOT(axisMinorTicksLengthChanged(qreal)));
 	connect(m_axis, SIGNAL(minorTicksOpacityChanged(qreal)), this, SLOT(axisMinorTicksOpacityChanged(qreal)));
 
 	// labels
 	connect(m_axis, SIGNAL(labelsFormatChanged(Axis::LabelsFormat)), this, SLOT(axisLabelsFormatChanged(Axis::LabelsFormat)));
 	connect(m_axis, SIGNAL(labelsAutoPrecisionChanged(bool)), this, SLOT(axisLabelsAutoPrecisionChanged(bool)));
 	connect(m_axis, SIGNAL(labelsPrecisionChanged(int)), this, SLOT(axisLabelsPrecisionChanged(int)));
 	connect(m_axis, &Axis::labelsDateTimeFormatChanged, this, &AxisDock::axisLabelsDateTimeFormatChanged);
 	connect(m_axis, SIGNAL(labelsPositionChanged(Axis::LabelsPosition)), this, SLOT(axisLabelsPositionChanged(Axis::LabelsPosition)));
 	connect(m_axis, SIGNAL(labelsOffsetChanged(double)), this, SLOT(axisLabelsOffsetChanged(double)));
 	connect(m_axis, SIGNAL(labelsRotationAngleChanged(qreal)), this, SLOT(axisLabelsRotationAngleChanged(qreal)));
 	connect(m_axis, SIGNAL(labelsFontChanged(QFont)), this, SLOT(axisLabelsFontChanged(QFont)));
 	connect(m_axis, SIGNAL(labelsColorChanged(QColor)), this, SLOT(axisLabelsFontColorChanged(QColor)));
 	connect(m_axis, SIGNAL(labelsPrefixChanged(QString)), this, SLOT(axisLabelsPrefixChanged(QString)));
 	connect(m_axis, SIGNAL(labelsSuffixChanged(QString)), this, SLOT(axisLabelsSuffixChanged(QString)));
 	connect(m_axis, SIGNAL(labelsOpacityChanged(qreal)), this, SLOT(axisLabelsOpacityChanged(qreal)));
 
 	// grids
 	connect(m_axis, SIGNAL(majorGridPenChanged(QPen)), this, SLOT(axisMajorGridPenChanged(QPen)));
 	connect(m_axis, SIGNAL(majorGridOpacityChanged(qreal)), this, SLOT(axisMajorGridOpacityChanged(qreal)));
 	connect(m_axis, SIGNAL(minorGridPenChanged(QPen)), this, SLOT(axisMinorGridPenChanged(QPen)));
 	connect(m_axis, SIGNAL(minorGridOpacityChanged(qreal)), this, SLOT(axisMinorGridOpacityChanged(qreal)));
 
 	connect(m_axis, SIGNAL(visibilityChanged(bool)), this, SLOT(axisVisibilityChanged(bool)));
 
 	m_initializing = false;
 }
 
 void AxisDock::activateTitleTab() {
 	ui.tabWidget->setCurrentWidget(ui.tabTitle);
 }
 
 void AxisDock::setModelIndexFromColumn(TreeViewComboBox* cb, const AbstractColumn* column) {
 	if (column)
 		cb->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(column));
 	else
 		cb->setCurrentModelIndex(QModelIndex());
 }
 
 //*************************************************************
 //********** SLOTs for changes triggered in AxisDock **********
 //*************************************************************
 //"General"-tab
 void AxisDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_axis->setName(ui.leName->text());
 }
 
 void AxisDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_axis->setComment(ui.leComment->text());
 }
 
 void AxisDock::visibilityChanged(bool state) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setVisible(state);
 }
 
 /*!
 	called if the orientation (horizontal or vertical) of the current axis is changed.
 */
 void AxisDock::orientationChanged(int index) {
 	auto orientation = (Axis::AxisOrientation)index;
 	if (orientation == Axis::AxisHorizontal) {
 		ui.cbPosition->setItemText(0, i18n("Top") );
 		ui.cbPosition->setItemText(1, i18n("Bottom") );
 		ui.cbLabelsPosition->setItemText(1, i18n("Top") );
 		ui.cbLabelsPosition->setItemText(2, i18n("Bottom") );
 
 		ui.cbScale->setItemText(1, QLatin1String("log(x)") );
 		ui.cbScale->setItemText(2, QLatin1String("log2(x)") );
 		ui.cbScale->setItemText(3, QLatin1String("ln(x)") );
 		ui.cbScale->setItemText(4, QLatin1String("sqrt(x)") );
 		ui.cbScale->setItemText(5, QLatin1String("x^2") );
 	} else { //vertical
 		ui.cbPosition->setItemText(0, i18n("Left") );
 		ui.cbPosition->setItemText(1, i18n("Right") );
 		ui.cbLabelsPosition->setItemText(1, i18n("Right") );
 		ui.cbLabelsPosition->setItemText(2, i18n("Left") );
 
 		ui.cbScale->setItemText(1, QLatin1String("log(y)") );
 		ui.cbScale->setItemText(2, QLatin1String("log2(y)") );
 		ui.cbScale->setItemText(3, QLatin1String("ln(y)") );
 		ui.cbScale->setItemText(4, QLatin1String("sqrt(y)") );
 		ui.cbScale->setItemText(5, QLatin1String("y^2") );
 	}
 
 	if (m_initializing)
 		return;
 
 	//depending on the current orientation we need to update axis possition and labels position
 
 	//axis position, map from the current index in the combobox to the enum value in Axis::AxisPosition
 	Axis::AxisPosition axisPosition;
 	int posIndex = ui.cbPosition->currentIndex();
 	if (orientation == Axis::AxisHorizontal) {
 		if (posIndex > 1)
 			posIndex += 2;
 		axisPosition = Axis::AxisPosition(posIndex);
 	} else {
 		axisPosition = Axis::AxisPosition(posIndex+2);
 	}
 
 	//labels position
 	posIndex = ui.cbLabelsPosition->currentIndex();
 	auto labelsPosition = Axis::LabelsPosition(posIndex);
 
 	for (auto* axis : m_axesList) {
 		axis->beginMacro(i18n("%1: set axis orientation", axis->name()));
 		axis->setOrientation(orientation);
 		axis->setPosition(axisPosition);
 		axis->setLabelsPosition(labelsPosition);
 		axis->endMacro();
 	}
 }
 
 /*!
 	called if one of the predefined axis positions
 	(top, bottom, left, right, center or custom) was changed.
 */
 void AxisDock::positionChanged(int index) {
 	if (index == -1)
 		return;	//we occasionally get -1 here, nothing to do in this case
 
 	if (index == 3)
 		ui.lePosition->setVisible(true);
 	else
 		ui.lePosition->setVisible(false);
 
 	if (m_initializing)
 		return;
 
 	//map from the current index in the combo box to the enum value in Axis::AxisPosition,
 	//depends on the current orientation
 	Axis::AxisPosition position;
 	if ( ui.cbOrientation->currentIndex() == 0 ) {
 		if (index>1)
 			index += 2;
 		position = Axis::AxisPosition(index);
 	} else {
 		position = Axis::AxisPosition(index+2);
 	}
 
 	for (auto* axis : m_axesList)
 		axis->setPosition(position);
 }
 
 /*!
 	called when the custom position of the axis in the corresponding LineEdit is changed.
 */
 void AxisDock::positionChanged() {
 	if (m_initializing)
 		return;
 
 	double offset = ui.lePosition->text().toDouble();
 	for (auto* axis : m_axesList)
 		axis->setOffset(offset);
 }
 
 void AxisDock::scaleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto scale = (Axis::AxisScale)index;
 	for (auto* axis : m_axesList)
 		axis->setScale(scale);
 }
 
 void AxisDock::autoScaleChanged(int index) {
 	bool autoScale = index == Qt::Checked;
 	ui.leStart->setEnabled(!autoScale);
 	ui.leEnd->setEnabled(!autoScale);
 	ui.dateTimeEditStart->setEnabled(!autoScale);
 	ui.dateTimeEditEnd->setEnabled(!autoScale);
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setAutoScale(autoScale);
 }
 
 void AxisDock::startChanged() {
 	if (m_initializing)
 		return;
 
 	double value = ui.leStart->text().toDouble();
 
 	//check first, whether the value for the lower limit is valid for the log- and square root scaling. If not, set the default values.
 	auto scale = Axis::AxisScale(ui.cbScale->currentIndex());
 	if (scale == Axis::ScaleLog10 || scale == Axis::ScaleLog2 || scale == Axis::ScaleLn) {
 		if (value <= 0) {
 			KMessageBox::sorry(this,
 			                   i18n("The axes lower limit has a non-positive value. Default minimal value will be used."),
 			                   i18n("Wrong lower limit value") );
 			ui.leStart->setText( "0.01" );
 			value=0.01;
 		}
 	} else if (scale == Axis::ScaleSqrt) {
 		if (value < 0) {
 			KMessageBox::sorry(this,
 			                   i18n("The axes lower limit has a negative value. Default minimal value will be used."),
 			                   i18n("Wrong lower limit value") );
 			ui.leStart->setText( "0" );
 			value=0;
 		}
 	}
 
 	for (auto* axis : m_axesList)
 		axis->setStart(value);
 }
 
 void AxisDock::endChanged() {
 	if (m_initializing)
 		return;
 
 	double value = ui.leEnd->text().toDouble();
 	for (auto* axis : m_axesList)
 		axis->setEnd(value);
 }
 
 void AxisDock::startDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
 	for (auto* axis : m_axesList)
 		axis->setStart(value);
 }
 
 void AxisDock::endDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
 	for (auto* axis : m_axesList)
 		axis->setEnd(value);
 }
 
 void AxisDock::zeroOffsetChanged() {
 	if (m_initializing)
 		return;
 
 	double offset = ui.leZeroOffset->text().toDouble();
 	for (auto* axis : m_axesList)
 		axis->setZeroOffset(offset);
 }
 
 void AxisDock::scalingFactorChanged() {
 	if (m_initializing)
 		return;
 
 	double scalingFactor = ui.leScalingFactor->text().toDouble();
 	for (auto* axis : m_axesList)
 		axis->setScalingFactor(scalingFactor);
 }
 
 // "Line"-tab
 void AxisDock::lineStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	bool b = (penStyle != Qt::NoPen);
 	ui.lLineColor->setEnabled(b);
 	ui.kcbLineColor->setEnabled(b);
 	ui.lLineWidth->setEnabled(b);
 	ui.sbLineWidth->setEnabled(b);
 	ui.lLineOpacity->setEnabled(b);
 	ui.sbLineOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->linePen();
 		pen.setStyle(penStyle);
 		axis->setLinePen(pen);
 	}
 }
 
 void AxisDock::lineColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->linePen();
 		pen.setColor(color);
 		axis->setLinePen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, color);
 	m_initializing = false;
 }
 
 void AxisDock::lineWidthChanged(double  value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->linePen();
 		pen.setWidthF(Worksheet::convertToSceneUnits(value, Worksheet::Point));
 		axis->setLinePen(pen);
 	}
 }
 
 void AxisDock::lineOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setLineOpacity(opacity);
 }
 
 void AxisDock::arrowTypeChanged(int index) {
 	auto type = (Axis::ArrowType)index;
 	if (type == Axis::NoArrow) {
 		ui.cbArrowPosition->setEnabled(false);
 		ui.sbArrowSize->setEnabled(false);
 	} else {
 		ui.cbArrowPosition->setEnabled(true);
 		ui.sbArrowSize->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setArrowType(type);
 }
 
 void AxisDock::arrowPositionChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto position = (Axis::ArrowPosition)index;
 	for (auto* axis : m_axesList)
 		axis->setArrowPosition(position);
 }
 
 void AxisDock::arrowSizeChanged(int value) {
 	if (m_initializing)
 		return;
 
 	float v = Worksheet::convertToSceneUnits(value, Worksheet::Point);
 	for (auto* axis : m_axesList)
 		axis->setArrowSize(v);
 }
 
 //"Major ticks" tab
 void AxisDock::majorTicksDirectionChanged(int index) {
 	Axis::TicksDirection direction = Axis::TicksDirection(index);
 
 	bool b = (direction != Axis::noTicks);
 	ui.lMajorTicksType->setEnabled(b);
 	ui.cbMajorTicksType->setEnabled(b);
 	ui.lMajorTicksType->setEnabled(b);
 	ui.cbMajorTicksType->setEnabled(b);
 	ui.lMajorTicksNumber->setEnabled(b);
 	ui.sbMajorTicksNumber->setEnabled(b);
 	ui.lMajorTicksIncrement->setEnabled(b);
 	ui.leMajorTicksIncrement->setEnabled(b);
 	ui.lMajorTicksLineStyle->setEnabled(b);
 	ui.cbMajorTicksLineStyle->setEnabled(b);
 	if (b) {
 		auto penStyle = Qt::PenStyle(ui.cbMajorTicksLineStyle->currentIndex());
 		b = (penStyle != Qt::NoPen);
 	}
 	ui.lMajorTicksColor->setEnabled(b);
 	ui.kcbMajorTicksColor->setEnabled(b);
 	ui.lMajorTicksWidth->setEnabled(b);
 	ui.sbMajorTicksWidth->setEnabled(b);
 	ui.lMajorTicksLength->setEnabled(b);
 	ui.sbMajorTicksLength->setEnabled(b);
 	ui.lMajorTicksOpacity->setEnabled(b);
 	ui.sbMajorTicksOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksDirection(direction);
 }
 
 /*!
 	called if the current style of the ticks (Number or Increment) is changed.
 	Shows/hides the corresponding widgets.
 */
 void AxisDock::majorTicksTypeChanged(int index) {
 	auto type = Axis::TicksType(index);
 	if ( type == Axis::TicksTotalNumber) {
 		ui.lMajorTicksNumber->show();
 		ui.sbMajorTicksNumber->show();
 		ui.lMajorTicksIncrement->hide();
 		ui.leMajorTicksIncrement->hide();
 		ui.lMajorTicksColumn->hide();
 		cbMajorTicksColumn->hide();
 	} else if ( type == Axis::TicksIncrement) {
 		ui.lMajorTicksNumber->hide();
 		ui.sbMajorTicksNumber->hide();
 		ui.lMajorTicksIncrement->show();
 		ui.leMajorTicksIncrement->show();
 		ui.lMajorTicksColumn->hide();
 		cbMajorTicksColumn->hide();
 	} else {
 		ui.lMajorTicksNumber->hide();
 		ui.sbMajorTicksNumber->hide();
 		ui.lMajorTicksIncrement->hide();
 		ui.leMajorTicksIncrement->hide();
 		ui.lMajorTicksColumn->show();
 		cbMajorTicksColumn->show();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksType(type);
 }
 
 void AxisDock::majorTicksNumberChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksNumber(value);
 }
 
 void AxisDock::majorTicksIncrementChanged() {
 	if (m_initializing)
 		return;
 
 	double value = ui.leMajorTicksIncrement->text().toDouble();
-	if (value<0) value = -1*value; //don't allow negative values
+	if (value < 0) value = -1.*value; //don't allow negative values
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksIncrement(value);
 }
 
 void AxisDock::majorTicksLineStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	bool b = (penStyle != Qt::NoPen);
 	ui.lMajorTicksColor->setEnabled(b);
 	ui.kcbMajorTicksColor->setEnabled(b);
 	ui.lMajorTicksWidth->setEnabled(b);
 	ui.sbMajorTicksWidth->setEnabled(b);
 	ui.lMajorTicksLength->setEnabled(b);
 	ui.sbMajorTicksLength->setEnabled(b);
 	ui.lMajorTicksOpacity->setEnabled(b);
 	ui.sbMajorTicksOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->majorTicksPen();
 		pen.setStyle(penStyle);
 		axis->setMajorTicksPen(pen);
 	}
 }
 
 void AxisDock::majorTicksColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = nullptr;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column != nullptr);
 	}
 
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksColumn(column);
 }
 
 void AxisDock::majorTicksColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->majorTicksPen();
 		pen.setColor(color);
 		axis->setMajorTicksPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbMajorTicksLineStyle, color);
 	m_initializing = false;
 }
 
 void AxisDock::majorTicksWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->majorTicksPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		axis->setMajorTicksPen(pen);
 	}
 }
 
 void AxisDock::majorTicksLengthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksLength( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void AxisDock::majorTicksOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setMajorTicksOpacity(opacity);
 }
 
 //"Minor ticks" tab
 void AxisDock::minorTicksDirectionChanged(int index) {
 	Axis::TicksDirection direction = Axis::TicksDirection(index);
 	bool b = (direction != Axis::noTicks);
 	ui.lMinorTicksType->setEnabled(b);
 	ui.cbMinorTicksType->setEnabled(b);
 	ui.lMinorTicksType->setEnabled(b);
 	ui.cbMinorTicksType->setEnabled(b);
 	ui.lMinorTicksNumber->setEnabled(b);
 	ui.sbMinorTicksNumber->setEnabled(b);
 	ui.lMinorTicksIncrement->setEnabled(b);
 	ui.leMinorTicksIncrement->setEnabled(b);
 	ui.lMinorTicksLineStyle->setEnabled(b);
 	ui.cbMinorTicksLineStyle->setEnabled(b);
 	if (b) {
 		auto penStyle = Qt::PenStyle(ui.cbMinorTicksLineStyle->currentIndex());
 		b = (penStyle != Qt::NoPen);
 	}
 	ui.lMinorTicksColor->setEnabled(b);
 	ui.kcbMinorTicksColor->setEnabled(b);
 	ui.lMinorTicksWidth->setEnabled(b);
 	ui.sbMinorTicksWidth->setEnabled(b);
 	ui.lMinorTicksLength->setEnabled(b);
 	ui.sbMinorTicksLength->setEnabled(b);
 	ui.lMinorTicksOpacity->setEnabled(b);
 	ui.sbMinorTicksOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksDirection(direction);
 }
 
 void AxisDock::minorTicksTypeChanged(int index) {
 	auto type = Axis::TicksType(index);
 	if ( type == Axis::TicksTotalNumber) {
 		ui.lMinorTicksNumber->show();
 		ui.sbMinorTicksNumber->show();
 		ui.lMinorTicksIncrement->hide();
 		ui.leMinorTicksIncrement->hide();
 		ui.lMinorTicksColumn->hide();
 		cbMinorTicksColumn->hide();
 	} else if ( type == Axis::TicksIncrement) {
 		ui.lMinorTicksNumber->hide();
 		ui.sbMinorTicksNumber->hide();
 		ui.lMinorTicksIncrement->show();
 		ui.leMinorTicksIncrement->show();
 		ui.lMinorTicksColumn->hide();
 		cbMinorTicksColumn->hide();
 	} else {
 		ui.lMinorTicksNumber->hide();
 		ui.sbMinorTicksNumber->hide();
 		ui.lMinorTicksIncrement->hide();
 		ui.leMinorTicksIncrement->hide();
 		ui.lMinorTicksColumn->show();
 		cbMinorTicksColumn->show();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksType(type);
 }
 
 void AxisDock::minorTicksNumberChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksNumber(value);
 }
 
 void AxisDock::minorTicksIncrementChanged() {
 	if (m_initializing)
 		return;
 
 	double value = ui.leMinorTicksIncrement->text().toDouble();
-	if (value<0) value = -1*value; //don't allow negative values
+	if (value < 0) value = -1. * value; //don't allow negative values
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksIncrement(value);
 }
 
 void AxisDock::minorTicksColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 	Q_ASSERT(column != nullptr);
 
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksColumn(column);
 }
 
 void AxisDock::minorTicksLineStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	bool b = (penStyle != Qt::NoPen);
 	ui.lMinorTicksColor->setEnabled(b);
 	ui.kcbMinorTicksColor->setEnabled(b);
 	ui.lMinorTicksWidth->setEnabled(b);
 	ui.sbMinorTicksWidth->setEnabled(b);
 	ui.lMinorTicksLength->setEnabled(b);
 	ui.sbMinorTicksLength->setEnabled(b);
 	ui.lMinorTicksOpacity->setEnabled(b);
 	ui.sbMinorTicksOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->minorTicksPen();
 		pen.setStyle(penStyle);
 		axis->setMinorTicksPen(pen);
 	}
 }
 
 void AxisDock::minorTicksColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->minorTicksPen();
 		pen.setColor(color);
 		axis->setMinorTicksPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbMinorTicksLineStyle, color);
 	m_initializing = false;
 }
 
 void AxisDock::minorTicksWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->minorTicksPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		axis->setMinorTicksPen(pen);
 	}
 }
 
 void AxisDock::minorTicksLengthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksLength( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void AxisDock::minorTicksOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setMinorTicksOpacity(opacity);
 }
 
 //"Tick labels"-tab
 void AxisDock::labelsFormatChanged(int index) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsFormat(Axis::LabelsFormat(index));
 }
 
 void AxisDock::labelsPrecisionChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsPrecision(value);
 }
 
 
 void AxisDock::labelsAutoPrecisionChanged(int state) {
 	bool checked = (state == Qt::Checked);
 	ui.sbLabelsPrecision->setEnabled(!checked);
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsAutoPrecision(checked);
 }
 
 void AxisDock::labelsDateTimeFormatChanged(int) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsDateTimeFormat(ui.cbLabelsDateTimeFormat->currentText());
 }
 
 void AxisDock::labelsPositionChanged(int index) {
 	auto position = Axis::LabelsPosition(index);
 
 	bool b = (position != Axis::NoLabels);
 	ui.lLabelsOffset->setEnabled(b);
 	ui.sbLabelsOffset->setEnabled(b);
 	ui.lLabelsRotation->setEnabled(b);
 	ui.sbLabelsRotation->setEnabled(b);
 	ui.lLabelsFont->setEnabled(b);
 	ui.kfrLabelsFont->setEnabled(b);
 	ui.lLabelsColor->setEnabled(b);
 	ui.kcbLabelsFontColor->setEnabled(b);
 	ui.lLabelsPrefix->setEnabled(b);
 	ui.leLabelsPrefix->setEnabled(b);
 	ui.lLabelsSuffix->setEnabled(b);
 	ui.leLabelsSuffix->setEnabled(b);
 	ui.lLabelsOpacity->setEnabled(b);
 	ui.sbLabelsOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsPosition(position);
 }
 
 void AxisDock::labelsOffsetChanged(double value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsOffset( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void AxisDock::labelsRotationChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsRotationAngle(value);
 }
 
 void AxisDock::labelsPrefixChanged() {
 	if (m_initializing)
 		return;
 
 	QString prefix = ui.leLabelsPrefix->text();
 	for (auto* axis : m_axesList)
 		axis->setLabelsPrefix(prefix);
 }
 
 void AxisDock::labelsSuffixChanged() {
 	if (m_initializing)
 		return;
 
 	QString suffix = ui.leLabelsSuffix->text();
 	for (auto* axis : m_axesList)
 		axis->setLabelsSuffix(suffix);
 }
 
 void AxisDock::labelsFontChanged(const QFont& font) {
 	if (m_initializing)
 		return;
 
 	QFont labelsFont = font;
 	labelsFont.setPixelSize( Worksheet::convertToSceneUnits(font.pointSizeF(), Worksheet::Point) );
 	for (auto* axis : m_axesList)
 		axis->setLabelsFont( labelsFont );
 }
 
 void AxisDock::labelsFontColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	for (auto* axis : m_axesList)
 		axis->setLabelsColor(color);
 }
 
 void AxisDock::labelsOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setLabelsOpacity(opacity);
 }
 
 // "Grid"-tab
 //major grid
 void AxisDock::majorGridStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	bool b = (penStyle != Qt::NoPen);
 	ui.lMajorGridColor->setEnabled(b);
 	ui.kcbMajorGridColor->setEnabled(b);
 	ui.lMajorGridWidth->setEnabled(b);
 	ui.sbMajorGridWidth->setEnabled(b);
 	ui.lMajorGridOpacity->setEnabled(b);
 	ui.sbMajorGridOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->majorGridPen();
 		pen.setStyle(penStyle);
 		axis->setMajorGridPen(pen);
 	}
 }
 
 void AxisDock::majorGridColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->majorGridPen();
 		pen.setColor(color);
 		axis->setMajorGridPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbMajorGridStyle, color);
 	m_initializing = false;
 }
 
 void AxisDock::majorGridWidthChanged(double  value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->majorGridPen();
 		pen.setWidthF(Worksheet::convertToSceneUnits(value, Worksheet::Point));
 		axis->setMajorGridPen(pen);
 	}
 }
 
 void AxisDock::majorGridOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setMajorGridOpacity(opacity);
 }
 
 //minor grid
 void AxisDock::minorGridStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	bool b = (penStyle != Qt::NoPen);
 	ui.lMinorGridColor->setEnabled(b);
 	ui.kcbMinorGridColor->setEnabled(b);
 	ui.lMinorGridWidth->setEnabled(b);
 	ui.sbMinorGridWidth->setEnabled(b);
 	ui.lMinorGridOpacity->setEnabled(b);
 	ui.sbMinorGridOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->minorGridPen();
 		pen.setStyle(penStyle);
 		axis->setMinorGridPen(pen);
 	}
 }
 
 void AxisDock::minorGridColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen = axis->minorGridPen();
 		pen.setColor(color);
 		axis->setMinorGridPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbMinorGridStyle, color);
 	m_initializing = false;
 }
 
 void AxisDock::minorGridWidthChanged(double  value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* axis : m_axesList) {
 		pen=axis->minorGridPen();
 		pen.setWidthF(Worksheet::convertToSceneUnits(value, Worksheet::Point));
 		axis->setMinorGridPen(pen);
 	}
 }
 
 void AxisDock::minorGridOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* axis : m_axesList)
 		axis->setMinorGridOpacity(opacity);
 }
 
 //*************************************************************
 //************ SLOTs for changes triggered in Axis ************
 //*************************************************************
 void AxisDock::axisDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_axis != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text()) {
 		ui.leName->setText(aspect->name());
 	} else if (aspect->comment() != ui.leComment->text()) {
 		ui.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void AxisDock::axisOrientationChanged(Axis::AxisOrientation orientation) {
 	m_initializing = true;
 	ui.cbOrientation->setCurrentIndex( (int)orientation );
 	m_initializing = false;
 }
 
 void AxisDock::axisPositionChanged(Axis::AxisPosition position) {
 	m_initializing = true;
 
 	//map from the enum Axis::AxisOrientation to the index in the combo box
 	int index(position);
 	if (index > 1)
 		ui.cbPosition->setCurrentIndex(index-2);
 	else
 		ui.cbPosition->setCurrentIndex(index);
 
 	m_initializing = false;
 }
 
 void AxisDock::axisPositionChanged(float value) {
 	m_initializing = true;
 	ui.lePosition->setText( QString::number(value) );
 	m_initializing = false;
 }
 
 void AxisDock::axisScaleChanged(Axis::AxisScale scale) {
 	m_initializing = true;
 	ui.cbScale->setCurrentIndex( (int)scale );
 	m_initializing = false;
 }
 
 void AxisDock::axisAutoScaleChanged(bool on) {
 	m_initializing = true;
 	ui.chkAutoScale->setChecked(on);
 	m_initializing = false;
 }
 
 void AxisDock::axisStartChanged(double value) {
 	m_initializing = true;
 	ui.leStart->setText( QString::number(value) );
 	ui.dateTimeEditStart->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void AxisDock::axisEndChanged(double value) {
 	m_initializing = true;
 	ui.leEnd->setText( QString::number(value) );
 	ui.dateTimeEditEnd->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void AxisDock::axisZeroOffsetChanged(qreal value) {
 	m_initializing = true;
 	ui.leZeroOffset->setText( QString::number(value) );
 	m_initializing = false;
 }
 
 void AxisDock::axisScalingFactorChanged(qreal value) {
 	m_initializing = true;
 	ui.leScalingFactor->setText( QString::number(value) );
 	m_initializing = false;
 }
 
 //line
 void AxisDock::axisLinePenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbLineStyle->setCurrentIndex( pen.style() );
 	ui.kcbLineColor->setColor( pen.color() );
 	GuiTools::updatePenStyles(ui.cbLineStyle, pen.color() );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(), Worksheet::Point) );
 	m_initializing = false;
 }
 
 void AxisDock::axisArrowTypeChanged(Axis::ArrowType type) {
 	m_initializing = true;
 	ui.cbArrowType->setCurrentIndex((int)type);
 	m_initializing = false;
 }
 
 void AxisDock::axisLineOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbLineOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 void AxisDock::axisArrowPositionChanged(Axis::ArrowPosition position) {
 	m_initializing = true;
 	ui.cbArrowPosition->setCurrentIndex( (int)position );
 	m_initializing = false;
 }
 
 void AxisDock::axisArrowSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbArrowSize->setValue( (int)Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 
 //major ticks
 void AxisDock::axisMajorTicksDirectionChanged(Axis::TicksDirection direction) {
 	m_initializing = true;
 	ui.cbMajorTicksDirection->setCurrentIndex(direction);
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksTypeChanged(Axis::TicksType type) {
 	m_initializing = true;
 	ui.cbMajorTicksType->setCurrentIndex(type);
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksNumberChanged(int number) {
 	m_initializing = true;
 	ui.sbMajorTicksNumber->setValue(number);
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksIncrementChanged(qreal increment) {
 	m_initializing = true;
 	ui.leMajorTicksIncrement->setText( QString::number(increment));
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbMajorTicksLineStyle->setCurrentIndex(pen.style());
 	ui.kcbMajorTicksColor->setColor(pen.color());
 	ui.sbMajorTicksWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point) );
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksLengthChanged(qreal length) {
 	m_initializing = true;
 	ui.sbMajorTicksLength->setValue( Worksheet::convertFromSceneUnits(length,Worksheet::Point) );
 	m_initializing = false;
 }
 void AxisDock::axisMajorTicksOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbMajorTicksOpacity->setValue( round(opacity*100.0));
 	m_initializing = false;
 }
 
 //minor ticks
 void AxisDock::axisMinorTicksDirectionChanged(Axis::TicksDirection direction) {
 	m_initializing = true;
 	ui.cbMinorTicksDirection->setCurrentIndex(direction);
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksTypeChanged(Axis::TicksType type) {
 	m_initializing = true;
 	ui.cbMinorTicksType->setCurrentIndex(type);
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksNumberChanged(int number) {
 	m_initializing = true;
 	ui.sbMinorTicksNumber->setValue(number);
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksIncrementChanged(qreal increment) {
 	m_initializing = true;
 	ui.leMinorTicksIncrement->setText( QString::number(increment));
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbMinorTicksLineStyle->setCurrentIndex(pen.style());
 	ui.kcbMinorTicksColor->setColor(pen.color());
 	ui.sbMinorTicksWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point) );
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksLengthChanged(qreal length) {
 	m_initializing = true;
 	ui.sbMinorTicksLength->setValue( Worksheet::convertFromSceneUnits(length,Worksheet::Point) );
 	m_initializing = false;
 }
 void AxisDock::axisMinorTicksOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbMinorTicksOpacity->setValue(round(opacity*100.0));
 	m_initializing = false;
 }
 
 //labels
 void AxisDock::axisLabelsFormatChanged(Axis::LabelsFormat format) {
 	m_initializing = true;
 	ui.cbLabelsFormat->setCurrentIndex(format);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsAutoPrecisionChanged(bool on) {
 	m_initializing = true;
 	ui.chkLabelsAutoPrecision->setChecked((int) on);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsPrecisionChanged(int precision) {
 	m_initializing = true;
 	ui.sbLabelsPrecision->setValue(precision);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsDateTimeFormatChanged(const QString& format) {
 	m_initializing = true;
 	ui.cbLabelsDateTimeFormat->setCurrentText(format);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsPositionChanged(Axis::LabelsPosition position) {
 	m_initializing = true;
 	ui.cbLabelsPosition->setCurrentIndex(position);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsOffsetChanged(double offset) {
 	m_initializing = true;
 	ui.sbLabelsOffset->setValue( Worksheet::convertFromSceneUnits(offset, Worksheet::Point) );
 	m_initializing = false;
 }
 void AxisDock::axisLabelsRotationAngleChanged(qreal rotation) {
 	m_initializing = true;
 	ui.sbLabelsRotation->setValue(rotation);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsFontChanged(const QFont& font) {
 	m_initializing = true;
 	//we need to set the font size in points for KFontRequester
 	QFont newFont(font);
 	newFont.setPointSizeF( round(Worksheet::convertFromSceneUnits(font.pixelSize(), Worksheet::Point)) );
 	ui.kfrLabelsFont->setFont(newFont);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsFontColorChanged(const QColor& color) {
 	m_initializing = true;
 	ui.kcbLabelsFontColor->setColor(color);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsPrefixChanged(const QString& prefix) {
 	m_initializing = true;
 	ui.leLabelsPrefix->setText(prefix);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsSuffixChanged(const QString& suffix) {
 	m_initializing = true;
 	ui.leLabelsSuffix->setText(suffix);
 	m_initializing = false;
 }
 void AxisDock::axisLabelsOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbLabelsOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //grid
 void AxisDock::axisMajorGridPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbMajorGridStyle->setCurrentIndex((int) pen.style());
 	ui.kcbMajorGridColor->setColor(pen.color());
 	GuiTools::updatePenStyles(ui.cbMajorGridStyle, pen.color());
 	ui.sbMajorGridWidth->setValue(Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point));
 	m_initializing = false;
 }
 void AxisDock::axisMajorGridOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbMajorGridOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void AxisDock::axisMinorGridPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbMinorGridStyle->setCurrentIndex((int) pen.style());
 	ui.kcbMinorGridColor->setColor(pen.color());
 	GuiTools::updatePenStyles(ui.cbMinorGridStyle, pen.color());
 	ui.sbMinorGridWidth->setValue(Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point));
 	m_initializing = false;
 }
 void AxisDock::axisMinorGridOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbMinorGridOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 void AxisDock::axisVisibilityChanged(bool on) {
 	m_initializing = true;
 	ui.chkVisible->setChecked(on);
 	m_initializing = false;
 }
 
 //*************************************************************
 //************************* Settings **************************
 //*************************************************************
 void AxisDock::load() {
 	//General
 	ui.chkVisible->setChecked( m_axis->isVisible() );
 	ui.cbOrientation->setCurrentIndex( (int) m_axis->orientation() );
 
-	auto index = (int)m_axis->position();
+	int index = (int)m_axis->position();
 	if (index > 1)
 		ui.cbPosition->setCurrentIndex(index-2);
 	else
 		ui.cbPosition->setCurrentIndex(index);
 
 	ui.lePosition->setText( QString::number( m_axis->offset()) );
 	ui.cbScale->setCurrentIndex(  (int) m_axis->scale() );
 	ui.chkAutoScale->setChecked( m_axis->autoScale() );
 	ui.leStart->setText( QString::number(m_axis->start()) );
 	ui.leEnd->setText( QString::number(m_axis->end()) );
 
-	const auto plot = dynamic_cast<const CartesianPlot*>(m_axis->parentAspect());
+	const auto* plot = dynamic_cast<const CartesianPlot*>(m_axis->parentAspect());
 	if (plot) {
 		bool numeric = ( (m_axis->orientation() == Axis::AxisHorizontal && plot->xRangeFormat() == CartesianPlot::Numeric)
 			|| (m_axis->orientation() == Axis::AxisVertical && plot->yRangeFormat() == CartesianPlot::Numeric) );
 		ui.lStart->setVisible(numeric);
 		ui.lEnd->setVisible(numeric);
 		ui.leStart->setVisible(numeric);
 		ui.leEnd->setVisible(numeric);
 		ui.lStartDateTime->setVisible(!numeric);
 		ui.dateTimeEditStart->setVisible(!numeric);
 		ui.lEndDateTime->setVisible(!numeric);
 		ui.dateTimeEditEnd->setVisible(!numeric);
 
 		if (!numeric) {
 			if (m_axis->orientation() == Axis::AxisHorizontal) {
 				ui.dateTimeEditStart->setDisplayFormat(plot->xRangeDateTimeFormat());
 				ui.dateTimeEditEnd->setDisplayFormat(plot->xRangeDateTimeFormat());
 			} else {
 				ui.dateTimeEditStart->setDisplayFormat(plot->yRangeDateTimeFormat());
 				ui.dateTimeEditEnd->setDisplayFormat(plot->yRangeDateTimeFormat());
 			}
 			ui.dateTimeEditStart->setDateTime(QDateTime::fromMSecsSinceEpoch(m_axis->start()));
 			ui.dateTimeEditEnd->setDateTime(QDateTime::fromMSecsSinceEpoch(m_axis->end()));
 		}
 	}
 
 	ui.leZeroOffset->setText( QString::number(m_axis->zeroOffset()) );
 	ui.leScalingFactor->setText( QString::number(m_axis->scalingFactor()) );
 
 	//Line
 	ui.cbLineStyle->setCurrentIndex( (int) m_axis->linePen().style() );
 	ui.kcbLineColor->setColor( m_axis->linePen().color() );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(m_axis->linePen().widthF(),Worksheet::Point) );
 	ui.sbLineOpacity->setValue( round(m_axis->lineOpacity()*100.0) );
 	ui.cbArrowType->setCurrentIndex( (int)m_axis->arrowType() );
 	ui.cbArrowPosition->setCurrentIndex( (int)m_axis->arrowPosition() );
 	ui.sbArrowSize->setValue( (int)Worksheet::convertFromSceneUnits(m_axis->arrowSize(), Worksheet::Point) );
 
 	//Major ticks
 	ui.cbMajorTicksDirection->setCurrentIndex( (int) m_axis->majorTicksDirection() );
 	ui.cbMajorTicksType->setCurrentIndex( (int) m_axis->majorTicksType() );
 	ui.sbMajorTicksNumber->setValue( m_axis->majorTicksNumber() );
 	ui.leMajorTicksIncrement->setText( QString::number(m_axis->majorTicksIncrement()) );
 	ui.cbMajorTicksLineStyle->setCurrentIndex( (int) m_axis->majorTicksPen().style() );
 	ui.kcbMajorTicksColor->setColor( m_axis->majorTicksPen().color() );
 	ui.sbMajorTicksWidth->setValue( Worksheet::convertFromSceneUnits( m_axis->majorTicksPen().widthF(),Worksheet::Point) );
 	ui.sbMajorTicksLength->setValue( Worksheet::convertFromSceneUnits( m_axis->majorTicksLength(),Worksheet::Point) );
 	ui.sbMajorTicksOpacity->setValue( round(m_axis->majorTicksOpacity()*100.0) );
 
 	//Minor ticks
 	ui.cbMinorTicksDirection->setCurrentIndex( (int) m_axis->minorTicksDirection() );
 	ui.cbMinorTicksType->setCurrentIndex( (int) m_axis->minorTicksType() );
 	ui.sbMinorTicksNumber->setValue( m_axis->minorTicksNumber() );
 	ui.leMinorTicksIncrement->setText( QString::number( m_axis->minorTicksIncrement()) );
 	ui.cbMinorTicksLineStyle->setCurrentIndex( (int) m_axis->minorTicksPen().style() );
 	ui.kcbMinorTicksColor->setColor( m_axis->minorTicksPen().color() );
 	ui.sbMinorTicksWidth->setValue( Worksheet::convertFromSceneUnits(m_axis->minorTicksPen().widthF(),Worksheet::Point) );
 	ui.sbMinorTicksLength->setValue( Worksheet::convertFromSceneUnits(m_axis->minorTicksLength(),Worksheet::Point) );
 	ui.sbMinorTicksOpacity->setValue( round(m_axis->minorTicksOpacity()*100.0) );
 
 	//Extra ticks
 	//TODO
 
 	// Tick label
 	ui.cbLabelsFormat->setCurrentIndex( (int) m_axis->labelsFormat() );
 	ui.chkLabelsAutoPrecision->setChecked( (int) m_axis->labelsAutoPrecision() );
 	ui.sbLabelsPrecision->setValue( (int)m_axis->labelsPrecision() );
 	ui.cbLabelsDateTimeFormat->setCurrentText(m_axis->labelsDateTimeFormat());
 	ui.cbLabelsPosition->setCurrentIndex( (int) m_axis->labelsPosition() );
 	ui.sbLabelsOffset->setValue( Worksheet::convertFromSceneUnits(m_axis->labelsOffset(),Worksheet::Point) );
 	ui.sbLabelsRotation->setValue( m_axis->labelsRotationAngle() );
 	//we need to set the font size in points for KFontRequester
 	QFont font = m_axis->labelsFont();
 	font.setPointSizeF( round(Worksheet::convertFromSceneUnits(font.pixelSize(), Worksheet::Point)) );
 	ui.kfrLabelsFont->setFont( font );
 	ui.kcbLabelsFontColor->setColor( m_axis->labelsColor() );
 	ui.leLabelsPrefix->setText( m_axis->labelsPrefix() );
 	ui.leLabelsSuffix->setText( m_axis->labelsSuffix() );
 	ui.sbLabelsOpacity->setValue( round(m_axis->labelsOpacity()*100.0) );
 
 	//Grid
 	ui.cbMajorGridStyle->setCurrentIndex( (int) m_axis->majorGridPen().style() );
 	ui.kcbMajorGridColor->setColor( m_axis->majorGridPen().color() );
 	ui.sbMajorGridWidth->setValue( Worksheet::convertFromSceneUnits(m_axis->majorGridPen().widthF(),Worksheet::Point) );
 	ui.sbMajorGridOpacity->setValue( round(m_axis->majorGridOpacity()*100.0) );
 
 	ui.cbMinorGridStyle->setCurrentIndex( (int) m_axis->minorGridPen().style() );
 	ui.kcbMinorGridColor->setColor( m_axis->minorGridPen().color() );
 	ui.sbMinorGridWidth->setValue( Worksheet::convertFromSceneUnits(m_axis->minorGridPen().widthF(),Worksheet::Point) );
 	ui.sbMinorGridOpacity->setValue( round(m_axis->minorGridOpacity()*100.0) );
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, ui.kcbLineColor->color());
 	this->majorTicksTypeChanged(ui.cbMajorTicksType->currentIndex());
 	GuiTools::updatePenStyles(ui.cbMajorTicksLineStyle, ui.kcbMajorTicksColor->color());
 	this->minorTicksTypeChanged(ui.cbMinorTicksType->currentIndex());
 	GuiTools::updatePenStyles(ui.cbMinorTicksLineStyle, ui.kcbMinorTicksColor->color());
 	GuiTools::updatePenStyles(ui.cbMajorGridStyle, ui.kcbMajorGridColor->color());
 	GuiTools::updatePenStyles(ui.cbMinorGridStyle, ui.kcbMinorGridColor->color());
 	m_initializing = false;
 }
 
 void AxisDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index!=-1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	int size = m_axesList.size();
 	if (size>1)
 		m_axis->beginMacro(i18n("%1 axes: template \"%2\" loaded", size, name));
 	else
 		m_axis->beginMacro(i18n("%1: template \"%2\" loaded", m_axis->name(), name));
 
 	this->loadConfig(config);
 
 	m_axis->endMacro();
 }
 
 void AxisDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group( "Axis" );
 
 	//General
 	ui.cbOrientation->setCurrentIndex( group.readEntry("Orientation", (int) m_axis->orientation()) );
 
 	int index = group.readEntry("Position", (int) m_axis->position());
 	if (index > 1)
 		ui.cbPosition->setCurrentIndex(index-2);
 	else
 		ui.cbPosition->setCurrentIndex(index);
 
 	ui.lePosition->setText( QString::number( group.readEntry("PositionOffset", m_axis->offset())) );
 	ui.cbScale->setCurrentIndex( group.readEntry("Scale", (int) m_axis->scale()) );
 	ui.chkAutoScale->setChecked(group.readEntry("AutoScale", m_axis->autoScale()));
 	ui.leStart->setText( QString::number( group.readEntry("Start", m_axis->start())) );
 	ui.leEnd->setText( QString::number( group.readEntry("End", m_axis->end())) );
 	ui.leZeroOffset->setText( QString::number( group.readEntry("ZeroOffset", m_axis->zeroOffset())) );
 	ui.leScalingFactor->setText( QString::number( group.readEntry("ScalingFactor", m_axis->scalingFactor())) );
 
 	//Title
 	KConfigGroup axisLabelGroup = config.group("AxisLabel");
 	labelWidget->loadConfig(axisLabelGroup);
 
 	//Line
 	ui.cbLineStyle->setCurrentIndex( group.readEntry("LineStyle", (int) m_axis->linePen().style()) );
 	ui.kcbLineColor->setColor( group.readEntry("LineColor", m_axis->linePen().color()) );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("LineWidth", m_axis->linePen().widthF()),Worksheet::Point) );
 	ui.sbLineOpacity->setValue( round(group.readEntry("LineOpacity", m_axis->lineOpacity())*100.0) );
 	ui.cbArrowType->setCurrentIndex( group.readEntry("ArrowType", (int) m_axis->arrowType()) );
 	ui.cbArrowPosition->setCurrentIndex( group.readEntry("ArrowPosition", (int) m_axis->arrowPosition()) );
 	ui.sbArrowSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ArrowSize", m_axis->arrowSize()), Worksheet::Point) );
 
 	//Major ticks
 	ui.cbMajorTicksDirection->setCurrentIndex( group.readEntry("MajorTicksDirection", (int) m_axis->majorTicksDirection()) );
 	ui.cbMajorTicksType->setCurrentIndex( group.readEntry("MajorTicksType", (int) m_axis->majorTicksType()) );
 	ui.sbMajorTicksNumber->setValue( group.readEntry("MajorTicksNumber", m_axis->majorTicksNumber()) );
 	ui.leMajorTicksIncrement->setText( QString::number( group.readEntry("MajorTicksIncrement", m_axis->majorTicksIncrement())) );
 	ui.cbMajorTicksLineStyle->setCurrentIndex( group.readEntry("MajorTicksLineStyle", (int) m_axis->majorTicksPen().style()) );
 	ui.kcbMajorTicksColor->setColor( group.readEntry("MajorTicksColor", m_axis->majorTicksPen().color()) );
 	ui.sbMajorTicksWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MajorTicksWidth", m_axis->majorTicksPen().widthF()),Worksheet::Point) );
 	ui.sbMajorTicksLength->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MajorTicksLength", m_axis->majorTicksLength()),Worksheet::Point) );
 	ui.sbMajorTicksOpacity->setValue( round(group.readEntry("MajorTicksOpacity", m_axis->majorTicksOpacity())*100.0) );
 
 	//Minor ticks
 	ui.cbMinorTicksDirection->setCurrentIndex( group.readEntry("MinorTicksDirection", (int) m_axis->minorTicksDirection()) );
 	ui.cbMinorTicksType->setCurrentIndex( group.readEntry("MinorTicksType", (int) m_axis->minorTicksType()) );
 	ui.sbMinorTicksNumber->setValue( group.readEntry("MinorTicksNumber", m_axis->minorTicksNumber()) );
 	ui.leMinorTicksIncrement->setText( QString::number( group.readEntry("MinorTicksIncrement", m_axis->minorTicksIncrement())) );
 	ui.cbMinorTicksLineStyle->setCurrentIndex( group.readEntry("MinorTicksLineStyle", (int) m_axis->minorTicksPen().style()) );
 	ui.kcbMinorTicksColor->setColor( group.readEntry("MinorTicksColor", m_axis->minorTicksPen().color()) );
 	ui.sbMinorTicksWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MinorTicksWidth", m_axis->minorTicksPen().widthF()),Worksheet::Point) );
 	ui.sbMinorTicksLength->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MinorTicksLength", m_axis->minorTicksLength()),Worksheet::Point) );
 	ui.sbMinorTicksOpacity->setValue( round(group.readEntry("MinorTicksOpacity", m_axis->minorTicksOpacity())*100.0) );
 
 	//Extra ticks
 	//TODO
 
 	// Tick label
 	ui.cbLabelsFormat->setCurrentIndex( group.readEntry("LabelsFormat", (int) m_axis->labelsFormat()) );
 	ui.chkLabelsAutoPrecision->setChecked( group.readEntry("LabelsAutoPrecision", (int) m_axis->labelsAutoPrecision()) );
 	ui.sbLabelsPrecision->setValue( group.readEntry("LabelsPrecision", (int)m_axis->labelsPrecision()) );
 	ui.cbLabelsDateTimeFormat->setCurrentText( group.readEntry("LabelsDateTimeFormat", "yyyy-MM-dd hh:mm:ss") );
 	ui.cbLabelsPosition->setCurrentIndex( group.readEntry("LabelsPosition", (int) m_axis->labelsPosition()) );
 	ui.sbLabelsOffset->setValue( Worksheet::convertFromSceneUnits(group.readEntry("LabelsOffset", m_axis->labelsOffset()), Worksheet::Point) );
 	ui.sbLabelsRotation->setValue( group.readEntry("LabelsRotation", m_axis->labelsRotationAngle()) );
 	//we need to set the font size in points for KFontRequester
 	QFont font = m_axis->labelsFont();
 	font.setPointSizeF( round(Worksheet::convertFromSceneUnits(font.pixelSize(), Worksheet::Point)) );
 	ui.kfrLabelsFont->setFont( group.readEntry("LabelsFont", font) );
 	ui.kcbLabelsFontColor->setColor( group.readEntry("LabelsFontColor", m_axis->labelsColor()) );
 	ui.leLabelsPrefix->setText( group.readEntry("LabelsPrefix", m_axis->labelsPrefix()) );
 	ui.leLabelsSuffix->setText( group.readEntry("LabelsSuffix", m_axis->labelsSuffix()) );
 	ui.sbLabelsOpacity->setValue( round(group.readEntry("LabelsOpacity", m_axis->labelsOpacity())*100.0) );
 
 	//Grid
 	ui.cbMajorGridStyle->setCurrentIndex( group.readEntry("MajorGridStyle", (int) m_axis->majorGridPen().style()) );
 	ui.kcbMajorGridColor->setColor( group.readEntry("MajorGridColor", m_axis->majorGridPen().color()) );
 	ui.sbMajorGridWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MajorGridWidth", m_axis->majorGridPen().widthF()),Worksheet::Point) );
 	ui.sbMajorGridOpacity->setValue( round(group.readEntry("MajorGridOpacity", m_axis->majorGridOpacity())*100.0) );
 
 	ui.cbMinorGridStyle->setCurrentIndex( group.readEntry("MinorGridStyle", (int) m_axis->minorGridPen().style()) );
 	ui.kcbMinorGridColor->setColor( group.readEntry("MinorGridColor", m_axis->minorGridPen().color()) );
 	ui.sbMinorGridWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("MinorGridWidth", m_axis->minorGridPen().widthF()),Worksheet::Point) );
 	ui.sbMinorGridOpacity->setValue( round(group.readEntry("MinorGridOpacity", m_axis->minorGridOpacity())*100.0) );
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, ui.kcbLineColor->color());
 	this->majorTicksTypeChanged(ui.cbMajorTicksType->currentIndex());
 	GuiTools::updatePenStyles(ui.cbMajorTicksLineStyle, ui.kcbMajorTicksColor->color());
 	this->minorTicksTypeChanged(ui.cbMinorTicksType->currentIndex());
 	GuiTools::updatePenStyles(ui.cbMinorTicksLineStyle, ui.kcbMinorTicksColor->color());
 	GuiTools::updatePenStyles(ui.cbMajorGridStyle, ui.kcbMajorGridColor->color());
 	GuiTools::updatePenStyles(ui.cbMinorGridStyle, ui.kcbMinorGridColor->color());
 	m_initializing = false;
 }
 
 void AxisDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "Axis" );
 
 	//General
 	group.writeEntry("Orientation", ui.cbOrientation->currentIndex());
 
 	if (ui.cbPosition->currentIndex() == 2) {
 		group.writeEntry("Position", (int)Axis::AxisCentered);
 	} else if (ui.cbPosition->currentIndex() == 3) {
 		group.writeEntry("Position", (int)Axis::AxisCustom);
 	} else {
 		if ( ui.cbOrientation->currentIndex() == Axis::AxisHorizontal )
 			group.writeEntry("Position", ui.cbPosition->currentIndex());
 		else
 			group.writeEntry("Position", ui.cbPosition->currentIndex()+2);
 	}
 
 	group.writeEntry("PositionOffset", ui.lePosition->text());
 	group.writeEntry("Scale", ui.cbScale->currentIndex());
 	group.writeEntry("Start", ui.leStart->text());
 	group.writeEntry("End", ui.leEnd->text());
 	group.writeEntry("ZeroOffset", ui.leZeroOffset->text());
 	group.writeEntry("ScalingFactor", ui.leScalingFactor->text());
 
 	//Title
 	KConfigGroup axisLabelGroup = config.group("AxisLabel");
 	labelWidget->saveConfig(axisLabelGroup);
 
 	//Line
 	group.writeEntry("LineStyle", ui.cbLineStyle->currentIndex());
 	group.writeEntry("LineColor", ui.kcbLineColor->color());
 	group.writeEntry("LineWidth", Worksheet::convertToSceneUnits(ui.sbLineWidth->value(), Worksheet::Point));
 	group.writeEntry("LineOpacity", ui.sbLineOpacity->value()/100);
 
 	//Major ticks
 	group.writeEntry("MajorTicksDirection", ui.cbMajorTicksDirection->currentIndex());
 	group.writeEntry("MajorTicksType", ui.cbMajorTicksType->currentIndex());
 	group.writeEntry("MajorTicksNumber", ui.sbMajorTicksNumber->value());
 	group.writeEntry("MajorTicksIncrement", ui.leMajorTicksIncrement->text());
 	group.writeEntry("MajorTicksLineStyle", ui.cbMajorTicksLineStyle->currentIndex());
 	group.writeEntry("MajorTicksColor", ui.kcbMajorTicksColor->color());
 	group.writeEntry("MajorTicksWidth", Worksheet::convertToSceneUnits(ui.sbMajorTicksWidth->value(),Worksheet::Point));
 	group.writeEntry("MajorTicksLength", Worksheet::convertToSceneUnits(ui.sbMajorTicksLength->value(),Worksheet::Point));
 	group.writeEntry("MajorTicksOpacity", ui.sbMajorTicksOpacity->value()/100);
 
 	//Minor ticks
 	group.writeEntry("MinorTicksDirection", ui.cbMinorTicksDirection->currentIndex());
 	group.writeEntry("MinorTicksType", ui.cbMinorTicksType->currentIndex());
 	group.writeEntry("MinorTicksNumber", ui.sbMinorTicksNumber->value());
 	group.writeEntry("MinorTicksIncrement", ui.leMinorTicksIncrement->text());
 	group.writeEntry("MinorTicksLineStyle", ui.cbMinorTicksLineStyle->currentIndex());
 	group.writeEntry("MinorTicksColor", ui.kcbMinorTicksColor->color());
 	group.writeEntry("MinorTicksWidth", Worksheet::convertFromSceneUnits(ui.sbMinorTicksWidth->value(),Worksheet::Point));
 	group.writeEntry("MinorTicksLength", Worksheet::convertFromSceneUnits(ui.sbMinorTicksLength->value(),Worksheet::Point));
 	group.writeEntry("MinorTicksOpacity", ui.sbMinorTicksOpacity->value()/100);
 
 	//Extra ticks
 	// TODO
 
 	// Tick label
 	group.writeEntry("LabelsFormat", ui.cbLabelsFormat->currentIndex());
 	group.writeEntry("LabelsAutoPrecision", ui.chkLabelsAutoPrecision->isChecked());
 	group.writeEntry("LabelsPrecision", ui.sbLabelsPrecision->value());
 	group.writeEntry("LabelsPosition", ui.cbLabelsPosition->currentIndex());
 	group.writeEntry("LabelsOffset", Worksheet::convertToSceneUnits(ui.sbLabelsOffset->value(), Worksheet::Point));
 	group.writeEntry("LabelsRotation", ui.sbLabelsRotation->value());
 	group.writeEntry("LabelsFont", ui.kfrLabelsFont->font());
 	group.writeEntry("LabelsFontColor", ui.kcbLabelsFontColor->color());
 	group.writeEntry("LabelsPrefix", ui.leLabelsPrefix->text());
 	group.writeEntry("LabelsSuffix", ui.leLabelsSuffix->text());
 	group.writeEntry("LabelsOpacity", ui.sbLabelsOpacity->value()/100);
 
 	//Grid
 	group.writeEntry("MajorGridStyle", ui.cbMajorGridStyle->currentIndex());
 	group.writeEntry("MajorGridColor", ui.kcbMajorGridColor->color());
 	group.writeEntry("MajorGridWidth", Worksheet::convertToSceneUnits(ui.sbMajorGridWidth->value(), Worksheet::Point));
 	group.writeEntry("MajorGridOpacity", ui.sbMajorGridOpacity->value()/100);
 
 	group.writeEntry("MinorGridStyle", ui.cbMinorGridStyle->currentIndex());
 	group.writeEntry("MinorGridColor", ui.kcbMinorGridColor->color());
 	group.writeEntry("MinorGridWidth", Worksheet::convertToSceneUnits(ui.sbMinorGridWidth->value(), Worksheet::Point));
 	group.writeEntry("MinorGridOpacity", ui.sbMinorGridOpacity->value()/100);
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp b/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
index c5dc2184c..6cddb4e0a 100644
--- a/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
+++ b/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
@@ -1,1602 +1,1602 @@
 /***************************************************************************
     File                 : CartesianPlotDock.cpp
     Project              : LabPlot
     Description          : widget for cartesian plot properties
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2012-2013 by Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "CartesianPlotDock.h"
 #include "backend/worksheet/plots/PlotArea.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/core/column/Column.h"
 
 #include "kdefrontend/widgets/LabelWidget.h"
 #include "kdefrontend/GuiTools.h"
 #include "kdefrontend/TemplateHandler.h"
 #include "kdefrontend/ThemeHandler.h"
 
 #include <QCompleter>
 #include <QPainter>
 #include <QTimer>
 #include <QDir>
 #include <QDirModel>
 #include <QFileDialog>
 #include <QImageReader>
 #include <QButtonGroup>
 #include <QIntValidator>
 
 #include <KSharedConfig>
 
 /*!
   \class CartesianPlotDock
   \brief  Provides a widget for editing the properties of the cartesian plot currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 
 CartesianPlotDock::CartesianPlotDock(QWidget* parent) : QWidget(parent),
 	m_plot(nullptr),
 	labelWidget(nullptr),
 	m_initializing(false) {
 
 	ui.setupUi(this);
 
 	//"General"-tab
-	auto rangeButtonsGroup(new QButtonGroup);
+	auto* rangeButtonsGroup(new QButtonGroup);
 	rangeButtonsGroup->addButton(ui.rbRangeFirst);
 	rangeButtonsGroup->addButton(ui.rbRangeLast);
 	rangeButtonsGroup->addButton(ui.rbRangeFree);
 
 	//"Range breaks"-tab
 	ui.bAddXBreak->setIcon( QIcon::fromTheme("list-add") );
 	ui.bRemoveXBreak->setIcon( QIcon::fromTheme("list-remove") );
 	ui.cbXBreak->addItem("1");
 
 	ui.bAddYBreak->setIcon( QIcon::fromTheme("list-add") );
 	ui.bRemoveYBreak->setIcon( QIcon::fromTheme("list-remove") );
 	ui.cbYBreak->addItem("1");
 
 	//"Background"-tab
 	ui.bOpen->setIcon( QIcon::fromTheme("document-open") );
 
-	auto completer = new QCompleter(this);
+	auto* completer = new QCompleter(this);
 	completer->setModel(new QDirModel);
 	ui.leBackgroundFileName->setCompleter(completer);
 
 	//"Title"-tab
-	auto hboxLayout = new QHBoxLayout(ui.tabTitle);
+	auto* hboxLayout = new QHBoxLayout(ui.tabTitle);
 	labelWidget = new LabelWidget(ui.tabTitle);
 	hboxLayout->addWidget(labelWidget);
 	hboxLayout->setContentsMargins(2,2,2,2);
 	hboxLayout->setSpacing(2);
 	//adjust layouts in the tabs
 	for (int i = 0; i < ui.tabWidget->count(); ++i) {
-		auto layout = qobject_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
+		auto* layout = qobject_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
 		if (!layout)
 			continue;
 
 		layout->setContentsMargins(2,2,2,2);
 		layout->setHorizontalSpacing(2);
 		layout->setVerticalSpacing(2);
 	}
 
 	//Validators
 	ui.leRangeFirst->setValidator( new QIntValidator(ui.leRangeFirst) );
 	ui.leRangeLast->setValidator( new QIntValidator(ui.leRangeLast) );
 	ui.leXBreakStart->setValidator( new QDoubleValidator(ui.leXBreakStart) );
 	ui.leXBreakEnd->setValidator( new QDoubleValidator(ui.leXBreakEnd) );
 	ui.leYBreakStart->setValidator( new QDoubleValidator(ui.leYBreakStart) );
 	ui.leYBreakEnd->setValidator( new QDoubleValidator(ui.leYBreakEnd) );
 
 	//SIGNAL/SLOT
 	//General
 	connect(ui.leName, &QLineEdit::textChanged, this, &CartesianPlotDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &CartesianPlotDock::commentChanged);
 	connect( ui.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( ui.sbLeft, SIGNAL(valueChanged(double)), this, SLOT(geometryChanged()) );
 	connect( ui.sbTop, SIGNAL(valueChanged(double)), this, SLOT(geometryChanged()) );
 	connect( ui.sbWidth, SIGNAL(valueChanged(double)), this, SLOT(geometryChanged()) );
 	connect( ui.sbHeight, SIGNAL(valueChanged(double)), this, SLOT(geometryChanged()) );
 
 	connect( ui.leRangeFirst, SIGNAL(textChanged(QString)), this, SLOT(rangeFirstChanged(QString)) );
 	connect( ui.leRangeLast, SIGNAL(textChanged(QString)), this, SLOT(rangeLastChanged(QString)) );
 	connect( rangeButtonsGroup, SIGNAL(buttonClicked(QAbstractButton*)), this, SLOT(rangeTypeChanged()) );
 
 	connect(ui.chkAutoScaleX, &QCheckBox::stateChanged, this, &CartesianPlotDock::autoScaleXChanged);
 	connect(ui.leXMin, &QLineEdit::textChanged, this, &CartesianPlotDock::xMinChanged);
 	connect(ui.leXMax, &QLineEdit::textChanged, this, &CartesianPlotDock::xMaxChanged);
 	connect(ui.dateTimeEditXMin, &QDateTimeEdit::dateTimeChanged, this, &CartesianPlotDock::xMinDateTimeChanged);
 	connect(ui.dateTimeEditXMax, &QDateTimeEdit::dateTimeChanged, this, &CartesianPlotDock::xMaxDateTimeChanged);
 	connect( ui.cbXScaling, SIGNAL(currentIndexChanged(int)), this, SLOT(xScaleChanged(int)) );
 	connect(ui.cbXRangeFormat, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &CartesianPlotDock::xRangeFormatChanged);
 
 	connect(ui.chkAutoScaleY, &QCheckBox::stateChanged, this, &CartesianPlotDock::autoScaleYChanged);
 	connect(ui.leYMin, &QLineEdit::textChanged, this, &CartesianPlotDock::yMinChanged);
 	connect(ui.leYMax, &QLineEdit::textChanged, this, &CartesianPlotDock::yMaxChanged);
 	connect(ui.dateTimeEditYMin, &QDateTimeEdit::dateTimeChanged, this, &CartesianPlotDock::yMinDateTimeChanged);
 	connect(ui.dateTimeEditYMax, &QDateTimeEdit::dateTimeChanged, this, &CartesianPlotDock::yMaxDateTimeChanged);
 	connect( ui.cbYScaling, SIGNAL(currentIndexChanged(int)), this, SLOT(yScaleChanged(int)) );
 	connect(ui.cbYRangeFormat, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &CartesianPlotDock::yRangeFormatChanged);
 
 	//Range breaks
 	connect( ui.chkXBreak, SIGNAL(toggled(bool)), this, SLOT(toggleXBreak(bool)) );
 	connect( ui.bAddXBreak, SIGNAL(clicked()), this, SLOT(addXBreak()) );
 	connect( ui.bRemoveXBreak, SIGNAL(clicked()), this, SLOT(removeXBreak()) );
 	connect( ui.cbXBreak, SIGNAL(currentIndexChanged(int)), this, SLOT(currentXBreakChanged(int)) );
 	connect( ui.leXBreakStart, SIGNAL(textChanged(QString)), this, SLOT(xBreakStartChanged()) );
 	connect( ui.leXBreakEnd, SIGNAL(textChanged(QString)), this, SLOT(xBreakEndChanged()) );
 	connect( ui.sbXBreakPosition, SIGNAL(valueChanged(int)), this, SLOT(xBreakPositionChanged(int)) );
 	connect( ui.cbXBreakStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(xBreakStyleChanged(int)) );
 
 	connect( ui.chkYBreak, SIGNAL(toggled(bool)), this, SLOT(toggleYBreak(bool)) );
 	connect( ui.bAddYBreak, SIGNAL(clicked()), this, SLOT(addYBreak()) );
 	connect( ui.bRemoveYBreak, SIGNAL(clicked()), this, SLOT(removeYBreak()) );
 	connect( ui.cbYBreak, SIGNAL(currentIndexChanged(int)), this, SLOT(currentYBreakChanged(int)) );
 	connect( ui.leYBreakStart, SIGNAL(textChanged(QString)), this, SLOT(yBreakStartChanged()) );
 	connect( ui.leYBreakEnd, SIGNAL(textChanged(QString)), this, SLOT(yBreakEndChanged()) );
 	connect( ui.sbYBreakPosition, SIGNAL(valueChanged(int)), this, SLOT(yBreakPositionChanged(int)) );
 	connect( ui.cbYBreakStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(yBreakStyleChanged(int)) );
 
 	//Background
 	connect( ui.cbBackgroundType, SIGNAL(currentIndexChanged(int)), this, SLOT(backgroundTypeChanged(int)) );
 	connect( ui.cbBackgroundColorStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(backgroundColorStyleChanged(int)) );
 	connect( ui.cbBackgroundImageStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(backgroundImageStyleChanged(int)) );
 	connect( ui.cbBackgroundBrushStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(backgroundBrushStyleChanged(int)) );
 	connect( ui.bOpen, SIGNAL(clicked(bool)), this, SLOT(selectFile()) );
 	connect( ui.leBackgroundFileName, SIGNAL(textChanged(QString)), this, SLOT(fileNameChanged()) );
 	connect( ui.leBackgroundFileName, SIGNAL(textChanged(QString)), this, SLOT(fileNameChanged()) );
 	connect( ui.kcbBackgroundFirstColor, SIGNAL(changed(QColor)), this, SLOT(backgroundFirstColorChanged(QColor)) );
 	connect( ui.kcbBackgroundSecondColor, SIGNAL(changed(QColor)), this, SLOT(backgroundSecondColorChanged(QColor)) );
 	connect( ui.sbBackgroundOpacity, SIGNAL(valueChanged(int)), this, SLOT(backgroundOpacityChanged(int)) );
 
 	//Border
 	connect( ui.cbBorderStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(borderStyleChanged(int)) );
 	connect( ui.kcbBorderColor, SIGNAL(changed(QColor)), this, SLOT(borderColorChanged(QColor)) );
 	connect( ui.sbBorderWidth, SIGNAL(valueChanged(double)), this, SLOT(borderWidthChanged(double)) );
 	connect( ui.sbBorderCornerRadius, SIGNAL(valueChanged(double)), this, SLOT(borderCornerRadiusChanged(double)) );
 	connect( ui.sbBorderOpacity, SIGNAL(valueChanged(int)), this, SLOT(borderOpacityChanged(int)) );
 
 	//Padding
 	connect( ui.sbPaddingHorizontal, SIGNAL(valueChanged(double)), this, SLOT(horizontalPaddingChanged(double)) );
 	connect( ui.sbPaddingVertical, SIGNAL(valueChanged(double)), this, SLOT(verticalPaddingChanged(double)) );
 
 	//theme and template handlers
-	QFrame* frame = new QFrame(this);
-	auto layout = new QHBoxLayout(frame);
+	auto* frame = new QFrame(this);
+	auto* layout = new QHBoxLayout(frame);
 
 	m_themeHandler = new ThemeHandler(this);
 	layout->addWidget(m_themeHandler);
 	connect(m_themeHandler, SIGNAL(loadThemeRequested(QString)), this, SLOT(loadTheme(QString)));
 	connect(m_themeHandler, SIGNAL(saveThemeRequested(KConfig&)), this, SLOT(saveTheme(KConfig&)));
 	connect(m_themeHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 	//connect(this, SIGNAL(saveThemeEnable(bool)), m_themeHandler, SLOT(saveThemeEnable(bool)));
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::CartesianPlot);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::CartesianPlot);
 	layout->addWidget(templateHandler);
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 
 	ui.verticalLayout->addWidget(frame);
 
 	//TODO: activate the tab again once the functionality is implemented
 	ui.tabWidget->removeTab(2);
 
 	init();
 }
 
 void CartesianPlotDock::init() {
 	this->retranslateUi();
 
 	/*
 	 //TODO: activate later once range breaking is implemented
 	//create icons for the different styles for scale breaking
 	QPainter pa;
 	pa.setPen( QPen(Qt::SolidPattern, 0) );
 	QPixmap pm(20, 20);
 	ui.cbXBreakStyle->setIconSize( QSize(20,20) );
 	ui.cbYBreakStyle->setIconSize( QSize(20,20) );
 
 	//simple
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,8,10);
 	pa.drawLine(12,10,17,10);
 	pa.end();
 	ui.cbXBreakStyle->setItemIcon(0, pm);
 	ui.cbYBreakStyle->setItemIcon(0, pm);
 
 	//vertical
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,8,10);
 	pa.drawLine(12,10,17,10);
 	pa.drawLine(8,14,8,6);
 	pa.drawLine(12,14,12,6);
 	pa.end();
 	ui.cbXBreakStyle->setItemIcon(1, pm);
 	ui.cbYBreakStyle->setItemIcon(1, pm);
 
 	//sloped
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,8,10);
 	pa.drawLine(12,10,17,10);
 	pa.drawLine(6,14,10,6);
 	pa.drawLine(10,14,14,6);
 	pa.end();
 	ui.cbXBreakStyle->setItemIcon(2, pm);
 	ui.cbYBreakStyle->setItemIcon(2, pm);
 	*/
 }
 
 void CartesianPlotDock::setPlots(QList<CartesianPlot*> list) {
 	m_initializing = true;
 	m_plotList = list;
 	m_plot = list.first();
 
 	QList<TextLabel*> labels;
-	for (auto* plot: list)
+	for (auto* plot : list)
 		labels.append(plot->title());
 
 	labelWidget->setLabels(labels);
 
 	//if there is more then one plot in the list, disable the name and comment fields in the tab "general"
 	if (list.size() == 1) {
 		ui.lName->setEnabled(true);
 		ui.leName->setEnabled(true);
 		ui.lComment->setEnabled(true);
 		ui.leComment->setEnabled(true);
 
 		ui.leName->setText(m_plot->name());
 		ui.leComment->setText(m_plot->comment());
 	} else {
 		ui.lName->setEnabled(false);
 		ui.leName->setEnabled(false);
 		ui.lComment->setEnabled(false);
 		ui.leComment->setEnabled(false);
 
 		ui.leName->setText("");
 		ui.leComment->setText("");
 	}
 
 	//show the properties of the first plot
 	this->load();
 
 	//update active widgets
 	backgroundTypeChanged(ui.cbBackgroundType->currentIndex());
 
 	m_themeHandler->setCurrentTheme(m_plot->theme());
 
 	//Deactivate the geometry related widgets, if the worksheet layout is active.
 	//Currently, a plot can only be a child of the worksheet itself, so we only need to ask the parent aspect (=worksheet).
 	//TODO redesign this, if the hierarchy will be changend in future (a plot is a child of a new object group/container or so)
-	auto w = dynamic_cast<Worksheet*>(m_plot->parentAspect());
+	auto* w = dynamic_cast<Worksheet*>(m_plot->parentAspect());
 	if (w) {
 		bool b = (w->layout() == Worksheet::NoLayout);
 		ui.sbTop->setEnabled(b);
 		ui.sbLeft->setEnabled(b);
 		ui.sbWidth->setEnabled(b);
 		ui.sbHeight->setEnabled(b);
 		connect(w, SIGNAL(layoutChanged(Worksheet::Layout)), this, SLOT(layoutChanged(Worksheet::Layout)));
 	}
 
 	//SIGNALs/SLOTs
 	connect( m_plot, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(plotDescriptionChanged(const AbstractAspect*)) );
 	connect( m_plot, SIGNAL(rectChanged(QRectF&)), this, SLOT(plotRectChanged(QRectF&)) );
 	connect( m_plot, SIGNAL(rangeTypeChanged(CartesianPlot::RangeType)), this, SLOT(plotRangeTypeChanged(CartesianPlot::RangeType)) );
 	connect( m_plot, SIGNAL(rangeFirstValuesChanged(int)), this, SLOT(plotRangeFirstValuesChanged(int)) );
 	connect( m_plot, SIGNAL(rangeLastValuesChanged(int)), this, SLOT(plotRangeLastValuesChanged(int)) );
 	connect( m_plot, SIGNAL(xAutoScaleChanged(bool)), this, SLOT(plotXAutoScaleChanged(bool)) );
 	connect( m_plot, SIGNAL(xMinChanged(double)), this, SLOT(plotXMinChanged(double)) );
 	connect( m_plot, SIGNAL(xMaxChanged(double)), this, SLOT(plotXMaxChanged(double)) );
 	connect( m_plot, SIGNAL(xScaleChanged(int)), this, SLOT(plotXScaleChanged(int)) );
 	connect(m_plot, &CartesianPlot::xRangeFormatChanged, this, &CartesianPlotDock::plotXRangeFormatChanged);
 	connect( m_plot, SIGNAL(yAutoScaleChanged(bool)), this, SLOT(plotYAutoScaleChanged(bool)) );
 	connect( m_plot, SIGNAL(yMinChanged(double)), this, SLOT(plotYMinChanged(double)) );
 	connect( m_plot, SIGNAL(yMaxChanged(double)), this, SLOT(plotYMaxChanged(double)) );
 	connect( m_plot, SIGNAL(yScaleChanged(int)), this, SLOT(plotYScaleChanged(int)) );
 	connect(m_plot, &CartesianPlot::yRangeFormatChanged, this, &CartesianPlotDock::plotYRangeFormatChanged);
 	connect( m_plot, SIGNAL(visibleChanged(bool)), this, SLOT(plotVisibleChanged(bool)) );
 
 	//range breaks
 	connect( m_plot, SIGNAL(xRangeBreakingEnabledChanged(bool)), this, SLOT(plotXRangeBreakingEnabledChanged(bool)) );
 	connect( m_plot, SIGNAL(xRangeBreaksChanged(CartesianPlot::RangeBreaks)), this, SLOT(plotXRangeBreaksChanged(CartesianPlot::RangeBreaks)) );
 	connect( m_plot, SIGNAL(yRangeBreakingEnabledChanged(bool)), this, SLOT(plotYRangeBreakingEnabledChanged(bool)) );
 	connect( m_plot, SIGNAL(yRangeBreaksChanged(CartesianPlot::RangeBreaks)), this, SLOT(plotYRangeBreaksChanged(CartesianPlot::RangeBreaks)) );
 
 	// Plot Area
 	connect( m_plot->plotArea(), SIGNAL(backgroundTypeChanged(PlotArea::BackgroundType)), this, SLOT(plotBackgroundTypeChanged(PlotArea::BackgroundType)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundColorStyleChanged(PlotArea::BackgroundColorStyle)), this, SLOT(plotBackgroundColorStyleChanged(PlotArea::BackgroundColorStyle)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundImageStyleChanged(PlotArea::BackgroundImageStyle)), this, SLOT(plotBackgroundImageStyleChanged(PlotArea::BackgroundImageStyle)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundBrushStyleChanged(Qt::BrushStyle)), this, SLOT(plotBackgroundBrushStyleChanged(Qt::BrushStyle)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundFirstColorChanged(QColor&)), this, SLOT(plotBackgroundFirstColorChanged(QColor&)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundSecondColorChanged(QColor&)), this, SLOT(plotBackgroundSecondColorChanged(QColor&)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundFileNameChanged(QString&)), this, SLOT(plotBackgroundFileNameChanged(QString&)) );
 	connect( m_plot->plotArea(), SIGNAL(backgroundOpacityChanged(float)), this, SLOT(plotBackgroundOpacityChanged(float)) );
 	connect( m_plot->plotArea(), SIGNAL(borderPenChanged(QPen&)), this, SLOT(plotBorderPenChanged(QPen&)) );
 	connect( m_plot->plotArea(), SIGNAL(borderOpacityChanged(float)), this, SLOT(plotBorderOpacityChanged(float)) );
 	connect( m_plot, SIGNAL(horizontalPaddingChanged(float)), this, SLOT(plotHorizontalPaddingChanged(float)) );
 	connect( m_plot, SIGNAL(verticalPaddingChanged(float)), this, SLOT(plotVerticalPaddingChanged(float)) );
 
 	m_initializing = false;
 }
 
 void CartesianPlotDock::activateTitleTab() {
 	ui.tabWidget->setCurrentWidget(ui.tabTitle);
 }
 
 //************************************************************
 //**** SLOTs for changes triggered in CartesianPlotDock ******
 //************************************************************
 void CartesianPlotDock::retranslateUi() {
 	m_initializing = true;
 
 	//general
 	ui.cbXRangeFormat->addItem(i18n("numeric"));
 	ui.cbXRangeFormat->addItem(i18n("datetime"));
 	ui.cbYRangeFormat->addItem(i18n("numeric"));
 	ui.cbYRangeFormat->addItem(i18n("datetime"));
 
 	ui.cbXScaling->addItem( i18n("Linear") );
 	ui.cbXScaling->addItem( i18n("log(x)") );
 	ui.cbXScaling->addItem( i18n("log2(x)") );
 	ui.cbXScaling->addItem( i18n("ln(x)") );
 
 	ui.cbYScaling->addItem( i18n("linear") );
 	ui.cbYScaling->addItem( i18n("log(y)") );
 	ui.cbYScaling->addItem( i18n("log2(y)") );
 	ui.cbYScaling->addItem( i18n("ln(y)") );
 
 	//scale breakings
 	ui.cbXBreakStyle->addItem( i18n("Simple") );
 	ui.cbXBreakStyle->addItem( i18n("Vertical") );
 	ui.cbXBreakStyle->addItem( i18n("Sloped") );
 
 	ui.cbYBreakStyle->addItem( i18n("Simple") );
 	ui.cbYBreakStyle->addItem( i18n("Vertical") );
 	ui.cbYBreakStyle->addItem( i18n("Sloped") );
 
 	//plot area
 	ui.cbBackgroundType->addItem(i18n("Color"));
 	ui.cbBackgroundType->addItem(i18n("Image"));
 	ui.cbBackgroundType->addItem(i18n("Pattern"));
 
 	ui.cbBackgroundColorStyle->addItem(i18n("Single Color"));
 	ui.cbBackgroundColorStyle->addItem(i18n("Horizontal Gradient"));
 	ui.cbBackgroundColorStyle->addItem(i18n("Vertical Gradient"));
 	ui.cbBackgroundColorStyle->addItem(i18n("Diag. Gradient (From Top Left)"));
 	ui.cbBackgroundColorStyle->addItem(i18n("Diag. Gradient (From Bottom Left)"));
 	ui.cbBackgroundColorStyle->addItem(i18n("Radial Gradient"));
 
 	ui.cbBackgroundImageStyle->addItem(i18n("Scaled and Cropped"));
 	ui.cbBackgroundImageStyle->addItem(i18n("Scaled"));
 	ui.cbBackgroundImageStyle->addItem(i18n("Scaled, Keep Proportions"));
 	ui.cbBackgroundImageStyle->addItem(i18n("Centered"));
 	ui.cbBackgroundImageStyle->addItem(i18n("Tiled"));
 	ui.cbBackgroundImageStyle->addItem(i18n("Center Tiled"));
 
 	GuiTools::updatePenStyles(ui.cbBorderStyle, Qt::black);
 	GuiTools::updateBrushStyles(ui.cbBackgroundBrushStyle, Qt::SolidPattern);
 
 	m_initializing = false;
 }
 
 // "General"-tab
 void CartesianPlotDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_plot->setName(ui.leName->text());
 }
 
 void CartesianPlotDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_plot->setComment(ui.leComment->text());
 }
 
 void CartesianPlotDock::visibilityChanged(bool state) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setVisible(state);
 }
 
 void CartesianPlotDock::geometryChanged() {
 	if (m_initializing)
 		return;
 
 	float x = Worksheet::convertToSceneUnits(ui.sbLeft->value(), Worksheet::Centimeter);
 	float y = Worksheet::convertToSceneUnits(ui.sbTop->value(), Worksheet::Centimeter);
 	float w = Worksheet::convertToSceneUnits(ui.sbWidth->value(), Worksheet::Centimeter);
 	float h = Worksheet::convertToSceneUnits(ui.sbHeight->value(), Worksheet::Centimeter);
 
 	QRectF rect(x,y,w,h);
 	m_plot->setRect(rect);
 }
 
 /*!
     Called when the layout in the worksheet gets changed.
     Enables/disables the geometry widgets if the layout was deactivated/activated.
     Shows the new geometry values of the first plot if the layout was activated.
  */
 void CartesianPlotDock::layoutChanged(Worksheet::Layout layout) {
 	bool b = (layout == Worksheet::NoLayout);
 	ui.sbTop->setEnabled(b);
 	ui.sbLeft->setEnabled(b);
 	ui.sbWidth->setEnabled(b);
 	ui.sbHeight->setEnabled(b);
 }
 
 void CartesianPlotDock::rangeTypeChanged() {
 	CartesianPlot::RangeType type;
 	if (ui.rbRangeFirst->isChecked()) {
 		ui.leRangeFirst->setEnabled(true);
 		ui.leRangeLast->setEnabled(false);
 		type = CartesianPlot::RangeFirst;
 	} else if (ui.rbRangeLast->isChecked()) {
 		ui.leRangeFirst->setEnabled(false);
 		ui.leRangeLast->setEnabled(true);
 		type = CartesianPlot::RangeLast;
 	} else {
 		ui.leRangeFirst->setEnabled(false);
 		ui.leRangeLast->setEnabled(false);
 		type = CartesianPlot::RangeFree;
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setRangeType(type);
 }
 
 void CartesianPlotDock::rangeFirstChanged(const QString& text) {
 	if (m_initializing)
 		return;
 
 	const int value = text.toInt();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setRangeFirstValues(value);
 }
 
 void CartesianPlotDock::rangeLastChanged(const QString& text) {
 	if (m_initializing)
 		return;
 
 	const int value = text.toInt();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setRangeLastValues(value);
 }
 
 void CartesianPlotDock::autoScaleXChanged(int state) {
 	bool checked = (state==Qt::Checked);
 	ui.cbXRangeFormat->setEnabled(!checked);
 	ui.leXMin->setEnabled(!checked);
 	ui.leXMax->setEnabled(!checked);
 	ui.dateTimeEditXMin->setEnabled(!checked);
 	ui.dateTimeEditXMax->setEnabled(!checked);
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setAutoScaleX(checked);
 }
 
 void CartesianPlotDock::xMinChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float min = value.toDouble();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMin(min);
 }
 
 void CartesianPlotDock::xMaxChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float max = value.toDouble();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMax(max);
 }
 
 void CartesianPlotDock::xMinDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMin(value);
 }
 
 void CartesianPlotDock::xMaxDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMax(value);
 }
 
 /*!
     called on scale changes (linear, log) for the x-axis
  */
 void CartesianPlotDock::xScaleChanged(int scale) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXScale((CartesianPlot::Scale) scale);
 }
 
 void CartesianPlotDock::xRangeFormatChanged(int index) {
 	bool numeric = (index == 0);
 
 	ui.lXMin->setVisible(numeric);
 	ui.leXMin->setVisible(numeric);
 	ui.lXMax->setVisible(numeric);
 	ui.leXMax->setVisible(numeric);
 
 	ui.lXMinDateTime->setVisible(!numeric);
 	ui.dateTimeEditXMin->setVisible(!numeric);
 	ui.lXMaxDateTime->setVisible(!numeric);
 	ui.dateTimeEditXMax->setVisible(!numeric);
 
 	if (m_initializing)
 		return;
 
 	auto format = (CartesianPlot::RangeFormat)index;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeFormat(format);
 }
 
 void CartesianPlotDock::autoScaleYChanged(int state) {
 	bool checked = (state==Qt::Checked);
 	ui.cbYRangeFormat->setEnabled(!checked);
 	ui.leYMin->setEnabled(!checked);
 	ui.leYMax->setEnabled(!checked);
 	ui.dateTimeEditYMin->setEnabled(!checked);
 	ui.dateTimeEditYMax->setEnabled(!checked);
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setAutoScaleY(checked);
 }
 
 void CartesianPlotDock::yMinChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float min = value.toDouble();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYMin(min);
 }
 
 void CartesianPlotDock::yMaxChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float max = value.toDouble();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYMax(max);
 }
 
 void CartesianPlotDock::yMinDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMin(value);
 }
 
 void CartesianPlotDock::yMaxDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXMax(value);
 }
 
 /*!
     called on scale changes (linear, log) for the y-axis
  */
 void CartesianPlotDock::yScaleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto scale = (CartesianPlot::Scale)index;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYScale(scale);
 }
 
 void CartesianPlotDock::yRangeFormatChanged(int index) {
 	bool numeric = (index == 0);
 
 	ui.lYMin->setVisible(numeric);
 	ui.leYMin->setVisible(numeric);
 	ui.lYMax->setVisible(numeric);
 	ui.leYMax->setVisible(numeric);
 
 	ui.lYMinDateTime->setVisible(!numeric);
 	ui.dateTimeEditYMin->setVisible(!numeric);
 	ui.lYMaxDateTime->setVisible(!numeric);
 	ui.dateTimeEditYMax->setVisible(!numeric);
 
 	if (m_initializing)
 		return;
 
 	auto format = (CartesianPlot::RangeFormat)index;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeFormat(format);
 }
 
 // "Range Breaks"-tab
 
 // x-range breaks
 void CartesianPlotDock::toggleXBreak(bool b) {
 	ui.frameXBreakEdit->setEnabled(b);
 	ui.leXBreakStart->setEnabled(b);
 	ui.leXBreakEnd->setEnabled(b);
 	ui.sbXBreakPosition->setEnabled(b);
 	ui.cbXBreakStyle->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreakingEnabled(b);
 }
 
 void CartesianPlotDock::addXBreak() {
 	ui.bRemoveXBreak->setVisible(true);
 
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	CartesianPlot::RangeBreak b;
 	breaks.list<<b;
 	breaks.lastChanged = breaks.list.size() - 1;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 
 	ui.cbXBreak->addItem(QString::number(ui.cbXBreak->count()+1));
 	ui.cbXBreak->setCurrentIndex(ui.cbXBreak->count()-1);
 }
 
 void CartesianPlotDock::removeXBreak() {
 	ui.bRemoveXBreak->setVisible(m_plot->xRangeBreaks().list.size()>1);
 	int index = ui.cbXBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	breaks.list.takeAt(index);
 	breaks.lastChanged = -1;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 
 	ui.cbXBreak->clear();
 	for (int i = 1; i <= breaks.list.size(); ++i)
 		ui.cbXBreak->addItem(QString::number(i));
 
 	if (index < ui.cbXBreak->count()-1)
 		ui.cbXBreak->setCurrentIndex(index);
 	else
 		ui.cbXBreak->setCurrentIndex(ui.cbXBreak->count()-1);
 
 	ui.bRemoveXBreak->setVisible(ui.cbXBreak->count()!=1);
 }
 
 void CartesianPlotDock::currentXBreakChanged(int index) {
 	if (m_initializing)
 		return;
 
 	if (index == -1)
 		return;
 
 	m_initializing = true;
 	const CartesianPlot::RangeBreak rangeBreak = m_plot->xRangeBreaks().list.at(index);
 	QString str = std::isnan(rangeBreak.start) ? "" : QString::number(rangeBreak.start);
 	ui.leXBreakStart->setText(str);
 	str = std::isnan(rangeBreak.end) ? "" : QString::number(rangeBreak.end);
 	ui.leXBreakEnd->setText(str);
 	ui.sbXBreakPosition->setValue(rangeBreak.position*100);
 	ui.cbXBreakStyle->setCurrentIndex((int)rangeBreak.style);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::xBreakStartChanged() {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbXBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	breaks.list[index].start = ui.leXBreakStart->text().toDouble();
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::xBreakEndChanged() {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbXBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	breaks.list[index].end = ui.leXBreakEnd->text().toDouble();
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::xBreakPositionChanged(int value) {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbXBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	breaks.list[index].position = (float)value/100.;
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::xBreakStyleChanged(int styleIndex) {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbXBreak->currentIndex();
 	auto style = CartesianPlot::RangeBreakStyle(styleIndex);
 	CartesianPlot::RangeBreaks breaks = m_plot->xRangeBreaks();
 	breaks.list[index].style = style;
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setXRangeBreaks(breaks);
 }
 
 // y-range breaks
 void CartesianPlotDock::toggleYBreak(bool b) {
 	ui.frameYBreakEdit->setEnabled(b);
 	ui.leYBreakStart->setEnabled(b);
 	ui.leYBreakEnd->setEnabled(b);
 	ui.sbYBreakPosition->setEnabled(b);
 	ui.cbYBreakStyle->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreakingEnabled(b);
 }
 
 void CartesianPlotDock::addYBreak() {
 	ui.bRemoveYBreak->setVisible(true);
 
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	CartesianPlot::RangeBreak b;
 	breaks.list << b;
 	breaks.lastChanged = breaks.list.size() - 1;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 
 	ui.cbYBreak->addItem(QString::number(ui.cbYBreak->count()+1));
 	ui.cbYBreak->setCurrentIndex(ui.cbYBreak->count()-1);
 }
 
 void CartesianPlotDock::removeYBreak() {
 	ui.bRemoveYBreak->setVisible(m_plot->yRangeBreaks().list.size()>1);
 	int index = ui.cbYBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	breaks.list.takeAt(index);
 	breaks.lastChanged = -1;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 
 	ui.cbYBreak->clear();
 	for (int i = 1; i <= breaks.list.size(); ++i)
 		ui.cbYBreak->addItem(QString::number(i));
 
 	if (index < ui.cbYBreak->count()-1)
 		ui.cbYBreak->setCurrentIndex(index);
 	else
 		ui.cbYBreak->setCurrentIndex(ui.cbYBreak->count()-1);
 
 	ui.bRemoveYBreak->setVisible(ui.cbYBreak->count() != 1);
 }
 
 void CartesianPlotDock::currentYBreakChanged(int index) {
 	if (m_initializing)
 		return;
 
 	if (index == -1)
 		return;
 
 	m_initializing = true;
 	const CartesianPlot::RangeBreak rangeBreak = m_plot->yRangeBreaks().list.at(index);
 	QString str = std::isnan(rangeBreak.start) ? "" : QString::number(rangeBreak.start);
 	ui.leYBreakStart->setText(str);
 	str = std::isnan(rangeBreak.end) ? "" : QString::number(rangeBreak.end);
 	ui.leYBreakEnd->setText(str);
 	ui.sbYBreakPosition->setValue(rangeBreak.position*100);
 	ui.cbYBreakStyle->setCurrentIndex((int)rangeBreak.style);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::yBreakStartChanged() {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbYBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	breaks.list[index].start = ui.leYBreakStart->text().toDouble();
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::yBreakEndChanged() {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbYBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	breaks.list[index].end = ui.leYBreakEnd->text().toDouble();
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::yBreakPositionChanged(int value) {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbYBreak->currentIndex();
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	breaks.list[index].position = (float)value/100.;
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 }
 
 void CartesianPlotDock::yBreakStyleChanged(int styleIndex) {
 	if (m_initializing)
 		return;
 
 	int index = ui.cbYBreak->currentIndex();
 	auto style = CartesianPlot::RangeBreakStyle(styleIndex);
 	CartesianPlot::RangeBreaks breaks = m_plot->yRangeBreaks();
 	breaks.list[index].style = style;
 	breaks.lastChanged = index;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setYRangeBreaks(breaks);
 }
 
 // "Plot area"-tab
 void CartesianPlotDock::backgroundTypeChanged(int index) {
 	auto type = (PlotArea::BackgroundType)index;
 
 	if (type == PlotArea::Color) {
 		ui.lBackgroundColorStyle->show();
 		ui.cbBackgroundColorStyle->show();
 		ui.lBackgroundImageStyle->hide();
 		ui.cbBackgroundImageStyle->hide();
 		ui.lBackgroundBrushStyle->hide();
 		ui.cbBackgroundBrushStyle->hide();
 
 		ui.lBackgroundFileName->hide();
 		ui.leBackgroundFileName->hide();
 		ui.bOpen->hide();
 
 		ui.lBackgroundFirstColor->show();
 		ui.kcbBackgroundFirstColor->show();
 
 		auto style = (PlotArea::BackgroundColorStyle) ui.cbBackgroundColorStyle->currentIndex();
 		if (style == PlotArea::SingleColor) {
 			ui.lBackgroundFirstColor->setText(i18n("Color:"));
 			ui.lBackgroundSecondColor->hide();
 			ui.kcbBackgroundSecondColor->hide();
 		} else {
 			ui.lBackgroundFirstColor->setText(i18n("First color:"));
 			ui.lBackgroundSecondColor->show();
 			ui.kcbBackgroundSecondColor->show();
 		}
 	} else if (type == PlotArea::Image) {
 		ui.lBackgroundColorStyle->hide();
 		ui.cbBackgroundColorStyle->hide();
 		ui.lBackgroundImageStyle->show();
 		ui.cbBackgroundImageStyle->show();
 		ui.lBackgroundBrushStyle->hide();
 		ui.cbBackgroundBrushStyle->hide();
 		ui.lBackgroundFileName->show();
 		ui.leBackgroundFileName->show();
 		ui.bOpen->show();
 
 		ui.lBackgroundFirstColor->hide();
 		ui.kcbBackgroundFirstColor->hide();
 		ui.lBackgroundSecondColor->hide();
 		ui.kcbBackgroundSecondColor->hide();
 	} else if (type == PlotArea::Pattern) {
 		ui.lBackgroundFirstColor->setText(i18n("Color:"));
 		ui.lBackgroundColorStyle->hide();
 		ui.cbBackgroundColorStyle->hide();
 		ui.lBackgroundImageStyle->hide();
 		ui.cbBackgroundImageStyle->hide();
 		ui.lBackgroundBrushStyle->show();
 		ui.cbBackgroundBrushStyle->show();
 		ui.lBackgroundFileName->hide();
 		ui.leBackgroundFileName->hide();
 		ui.bOpen->hide();
 
 		ui.lBackgroundFirstColor->show();
 		ui.kcbBackgroundFirstColor->show();
 		ui.lBackgroundSecondColor->hide();
 		ui.kcbBackgroundSecondColor->hide();
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundType(type);
 }
 
 void CartesianPlotDock::backgroundColorStyleChanged(int index) {
 	auto style = (PlotArea::BackgroundColorStyle)index;
 
 	if (style == PlotArea::SingleColor) {
 		ui.lBackgroundFirstColor->setText(i18n("Color:"));
 		ui.lBackgroundSecondColor->hide();
 		ui.kcbBackgroundSecondColor->hide();
 	} else {
 		ui.lBackgroundFirstColor->setText(i18n("First color:"));
 		ui.lBackgroundSecondColor->show();
 		ui.kcbBackgroundSecondColor->show();
 		ui.lBackgroundBrushStyle->hide();
 		ui.cbBackgroundBrushStyle->hide();
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundColorStyle(style);
 }
 
 void CartesianPlotDock::backgroundImageStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto style = (PlotArea::BackgroundImageStyle)index;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundImageStyle(style);
 }
 
 void CartesianPlotDock::backgroundBrushStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto style = (Qt::BrushStyle)index;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundBrushStyle(style);
 }
 
 void CartesianPlotDock::backgroundFirstColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundFirstColor(c);
 }
 
 void CartesianPlotDock::backgroundSecondColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundSecondColor(c);
 }
 
 /*!
     opens a file dialog and lets the user select the image file.
 */
 void CartesianPlotDock::selectFile() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "CartesianPlotDock");
 	QString dir = conf.readEntry("LastImageDir", "");
 
 	QString formats;
-	for (const auto& format: QImageReader::supportedImageFormats()) {
+	for (const auto& format : QImageReader::supportedImageFormats()) {
 		QString f = "*." + QString(format.constData());
 		formats.isEmpty() ? formats+=f : formats+=' '+f;
 	}
 
 	QString path = QFileDialog::getOpenFileName(this, i18n("Select the image file"), dir, i18n("Images (%1)", formats));
 	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("LastImageDir", newDir);
 	}
 
 	ui.leBackgroundFileName->setText( path );
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundFileName(path);
 }
 
 void CartesianPlotDock::fileNameChanged() {
 	if (m_initializing)
 		return;
 
 	QString fileName = ui.leBackgroundFileName->text();
 	if (!fileName.isEmpty() && !QFile::exists(fileName))
 		ui.leBackgroundFileName->setStyleSheet("QLineEdit{background:red;}");
 	else
 		ui.leBackgroundFileName->setStyleSheet("");
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundFileName(fileName);
 }
 
 void CartesianPlotDock::backgroundOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundOpacity(opacity);
 }
 
 // "Border"-tab
 void CartesianPlotDock::borderStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto penStyle = Qt::PenStyle(index);
 	QPen pen;
-	for (auto* plot: m_plotList) {
+	for (auto* plot : m_plotList) {
 		pen = plot->plotArea()->borderPen();
 		pen.setStyle(penStyle);
 		plot->plotArea()->setBorderPen(pen);
 	}
 }
 
 void CartesianPlotDock::borderColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
-	for (auto* plot: m_plotList) {
+	for (auto* plot : m_plotList) {
 		pen = plot->plotArea()->borderPen();
 		pen.setColor(color);
 		plot->plotArea()->setBorderPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbBorderStyle, color);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::borderWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
-	for (auto* plot: m_plotList) {
+	for (auto* plot : m_plotList) {
 		pen = plot->plotArea()->borderPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		plot->plotArea()->setBorderPen(pen);
 	}
 }
 
 void CartesianPlotDock::borderCornerRadiusChanged(double value) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBorderCornerRadius(Worksheet::convertToSceneUnits(value, Worksheet::Centimeter));
 }
 
 void CartesianPlotDock::borderOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->plotArea()->setBorderOpacity(opacity);
 }
 
 void CartesianPlotDock::horizontalPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setHorizontalPadding(Worksheet::convertToSceneUnits(value, Worksheet::Centimeter));
 }
 
 void CartesianPlotDock::verticalPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setVerticalPadding(Worksheet::convertToSceneUnits(value, Worksheet::Centimeter));
 }
 
 //*************************************************************
 //****** SLOTs for changes triggered in CartesianPlot *********
 //*************************************************************
 //general
 void CartesianPlotDock::plotDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_plot != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.leComment->text())
 		ui.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotRectChanged(QRectF& rect) {
 	m_initializing = true;
 	ui.sbLeft->setValue(Worksheet::convertFromSceneUnits(rect.x(), Worksheet::Centimeter));
 	ui.sbTop->setValue(Worksheet::convertFromSceneUnits(rect.y(), Worksheet::Centimeter));
 	ui.sbWidth->setValue(Worksheet::convertFromSceneUnits(rect.width(), Worksheet::Centimeter));
 	ui.sbHeight->setValue(Worksheet::convertFromSceneUnits(rect.height(), Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotRangeTypeChanged(CartesianPlot::RangeType type) {
 	m_initializing = true;
 	switch (type) {
 	case CartesianPlot::RangeFree:
 		ui.rbRangeFree->setChecked(true);
 		break;
 	case CartesianPlot::RangeFirst:
 		ui.rbRangeFirst->setChecked(true);
 		break;
 	case CartesianPlot::RangeLast:
 		ui.rbRangeLast->setChecked(true);
 		break;
 	}
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotRangeFirstValuesChanged(int value) {
 	m_initializing = true;
 	ui.leRangeFirst->setText(QString::number(value));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotRangeLastValuesChanged(int value) {
 	m_initializing = true;
 	ui.leRangeLast->setText(QString::number(value));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXAutoScaleChanged(bool value) {
 	m_initializing = true;
 	ui.chkAutoScaleX->setChecked(value);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXMinChanged(double value) {
 	m_initializing = true;
 	ui.leXMin->setText( QString::number(value) );
 	ui.dateTimeEditXMin->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXMaxChanged(double value) {
 	m_initializing = true;
 	ui.leXMax->setText( QString::number(value) );
 	ui.dateTimeEditXMax->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXScaleChanged(int scale) {
 	m_initializing = true;
 	ui.cbXScaling->setCurrentIndex( scale );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXRangeFormatChanged(CartesianPlot::RangeFormat format) {
 	m_initializing = true;
 	ui.cbXRangeFormat->setCurrentIndex(format);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYAutoScaleChanged(bool value) {
 	m_initializing = true;
 	ui.chkAutoScaleY->setChecked(value);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYMinChanged(double value) {
 	m_initializing = true;
 	ui.leYMin->setText( QString::number(value) );
 	ui.dateTimeEditYMin->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYMaxChanged(double value) {
 	m_initializing = true;
 	ui.leYMax->setText( QString::number(value) );
 	ui.dateTimeEditYMax->setDateTime( QDateTime::fromMSecsSinceEpoch(value) );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYScaleChanged(int scale) {
 	m_initializing = true;
 	ui.cbYScaling->setCurrentIndex( scale );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYRangeFormatChanged(CartesianPlot::RangeFormat format) {
 	m_initializing = true;
 	ui.cbYRangeFormat->setCurrentIndex(format);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotVisibleChanged(bool on) {
 	m_initializing = true;
 	ui.chkVisible->setChecked(on);
 	m_initializing = false;
 }
 
 //range breaks
 void CartesianPlotDock::plotXRangeBreakingEnabledChanged(bool on) {
 	m_initializing = true;
 	ui.chkXBreak->setChecked(on);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotXRangeBreaksChanged(const CartesianPlot::RangeBreaks& breaks) {
 	Q_UNUSED(breaks);
 }
 
 void CartesianPlotDock::plotYRangeBreakingEnabledChanged(bool on) {
 	m_initializing = true;
 	ui.chkYBreak->setChecked(on);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotYRangeBreaksChanged(const CartesianPlot::RangeBreaks& breaks) {
 	Q_UNUSED(breaks);
 }
 
 //background
 void CartesianPlotDock::plotBackgroundTypeChanged(PlotArea::BackgroundType type) {
 	m_initializing = true;
 	ui.cbBackgroundType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundColorStyleChanged(PlotArea::BackgroundColorStyle style) {
 	m_initializing = true;
 	ui.cbBackgroundColorStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundImageStyleChanged(PlotArea::BackgroundImageStyle style) {
 	m_initializing = true;
 	ui.cbBackgroundImageStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundBrushStyleChanged(Qt::BrushStyle style) {
 	m_initializing = true;
 	ui.cbBackgroundBrushStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundFirstColorChanged(QColor& color) {
 	m_initializing = true;
 	ui.kcbBackgroundFirstColor->setColor(color);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundSecondColorChanged(QColor& color) {
 	m_initializing = true;
 	ui.kcbBackgroundSecondColor->setColor(color);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundFileNameChanged(QString& filename) {
 	m_initializing = true;
 	ui.leBackgroundFileName->setText(filename);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBackgroundOpacityChanged(float opacity) {
 	m_initializing = true;
 	ui.sbBackgroundOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBorderPenChanged(QPen& pen) {
 	m_initializing = true;
 	if (ui.cbBorderStyle->currentIndex() != pen.style())
 		ui.cbBorderStyle->setCurrentIndex(pen.style());
 	if (ui.kcbBorderColor->color() != pen.color())
 		ui.kcbBorderColor->setColor(pen.color());
 	if (ui.sbBorderWidth->value() != pen.widthF())
 		ui.sbBorderWidth->setValue(Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBorderCornerRadiusChanged(float value) {
 	m_initializing = true;
 	ui.sbBorderCornerRadius->setValue(Worksheet::convertFromSceneUnits(value, Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBorderOpacityChanged(float value) {
 	m_initializing = true;
 	float v = (float)value*100.;
 	ui.sbBorderOpacity->setValue(v);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotHorizontalPaddingChanged(float value) {
 	m_initializing = true;
 	ui.sbPaddingHorizontal->setValue(Worksheet::convertFromSceneUnits(value, Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotVerticalPaddingChanged(float value) {
 	m_initializing = true;
 	ui.sbPaddingVertical->setValue(Worksheet::convertFromSceneUnits(value, Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 //*************************************************************
 //******************** SETTINGS *******************************
 //*************************************************************
 void CartesianPlotDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index != -1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	int size = m_plotList.size();
 	if (size > 1)
 		m_plot->beginMacro(i18n("%1 cartesian plots: template \"%2\" loaded", size, name));
 	else
 		m_plot->beginMacro(i18n("%1: template \"%2\" loaded", m_plot->name(), name));
 
 	this->loadConfig(config);
 
 	m_plot->endMacro();
 }
 
 void CartesianPlotDock::load() {
 	//General-tab
 	ui.chkVisible->setChecked(m_plot->isVisible());
 	ui.sbLeft->setValue(Worksheet::convertFromSceneUnits(m_plot->rect().x(), Worksheet::Centimeter));
 	ui.sbTop->setValue(Worksheet::convertFromSceneUnits(m_plot->rect().y(), Worksheet::Centimeter));
 	ui.sbWidth->setValue(Worksheet::convertFromSceneUnits(m_plot->rect().width(), Worksheet::Centimeter));
 	ui.sbHeight->setValue(Worksheet::convertFromSceneUnits(m_plot->rect().height(), Worksheet::Centimeter));
 
 	switch (m_plot->rangeType()) {
 	case CartesianPlot::RangeFree:
 		ui.rbRangeFree->setChecked(true);
 		break;
 	case CartesianPlot::RangeFirst:
 		ui.rbRangeFirst->setChecked(true);
 		break;
 	case CartesianPlot::RangeLast:
 		ui.rbRangeLast->setChecked(true);
 		break;
 	}
 	rangeTypeChanged();
 	ui.leRangeFirst->setText( QString::number(m_plot->rangeFirstValues()) );
 	ui.leRangeLast->setText( QString::number(m_plot->rangeLastValues()) );
 
 	ui.chkAutoScaleX->setChecked(m_plot->autoScaleX());
 	ui.leXMin->setText( QString::number(m_plot->xMin()) );
 	ui.leXMax->setText( QString::number(m_plot->xMax()) );
 	ui.dateTimeEditXMin->setDisplayFormat(m_plot->xRangeDateTimeFormat());
 	ui.dateTimeEditXMax->setDisplayFormat(m_plot->xRangeDateTimeFormat());
 	ui.dateTimeEditXMin->setDateTime(QDateTime::fromMSecsSinceEpoch(m_plot->xMin()));
 	ui.dateTimeEditXMax->setDateTime(QDateTime::fromMSecsSinceEpoch(m_plot->xMax()));
 	ui.cbXScaling->setCurrentIndex( (int) m_plot->xScale() );
 	ui.cbXRangeFormat->setCurrentIndex( (int) m_plot->xRangeFormat() );
 
 	ui.chkAutoScaleY->setChecked(m_plot->autoScaleY());
 	ui.leYMin->setText( QString::number(m_plot->yMin()) );
 	ui.leYMax->setText( QString::number(m_plot->yMax()) );
 	ui.dateTimeEditYMin->setDisplayFormat(m_plot->yRangeDateTimeFormat());
 	ui.dateTimeEditYMax->setDisplayFormat(m_plot->yRangeDateTimeFormat());
 	ui.dateTimeEditYMin->setDateTime(QDateTime::fromMSecsSinceEpoch(m_plot->yMin()));
 	ui.dateTimeEditYMax->setDateTime(QDateTime::fromMSecsSinceEpoch(m_plot->yMax()));
 	ui.cbYScaling->setCurrentIndex( (int)m_plot->yScale() );
 	ui.cbYRangeFormat->setCurrentIndex( (int) m_plot->yRangeFormat() );
 
 	//Title
 	labelWidget->load();
 
 	//x-range breaks, show the first break
 	ui.chkXBreak->setChecked(m_plot->xRangeBreakingEnabled());
 	this->toggleXBreak(m_plot->xRangeBreakingEnabled());
 	ui.bRemoveXBreak->setVisible(m_plot->xRangeBreaks().list.size()>1);
 	ui.cbXBreak->clear();
 	if (!m_plot->xRangeBreaks().list.isEmpty()) {
 		for (int i = 1; i <= m_plot->xRangeBreaks().list.size(); ++i)
 			ui.cbXBreak->addItem(QString::number(i));
 	} else
 		ui.cbXBreak->addItem("1");
 	ui.cbXBreak->setCurrentIndex(0);
 
 	//y-range breaks, show the first break
 	ui.chkYBreak->setChecked(m_plot->yRangeBreakingEnabled());
 	this->toggleYBreak(m_plot->yRangeBreakingEnabled());
 	ui.bRemoveYBreak->setVisible(m_plot->yRangeBreaks().list.size()>1);
 	ui.cbYBreak->clear();
 	if (!m_plot->yRangeBreaks().list.isEmpty()) {
 		for (int i = 1; i <= m_plot->yRangeBreaks().list.size(); ++i)
 			ui.cbYBreak->addItem(QString::number(i));
 	} else
 		ui.cbYBreak->addItem("1");
 	ui.cbYBreak->setCurrentIndex(0);
 
 	//"Plot Area"-tab
 	//Background
 	ui.cbBackgroundType->setCurrentIndex( (int)m_plot->plotArea()->backgroundType() );
 	ui.cbBackgroundColorStyle->setCurrentIndex( (int) m_plot->plotArea()->backgroundColorStyle() );
 	ui.cbBackgroundImageStyle->setCurrentIndex( (int) m_plot->plotArea()->backgroundImageStyle() );
 	ui.cbBackgroundBrushStyle->setCurrentIndex( (int) m_plot->plotArea()->backgroundBrushStyle() );
 	ui.leBackgroundFileName->setText( m_plot->plotArea()->backgroundFileName() );
 	ui.kcbBackgroundFirstColor->setColor( m_plot->plotArea()->backgroundFirstColor() );
 	ui.kcbBackgroundSecondColor->setColor( m_plot->plotArea()->backgroundSecondColor() );
 	ui.sbBackgroundOpacity->setValue( round(m_plot->plotArea()->backgroundOpacity()*100.0) );
 
 	//highlight the text field for the background image red if an image is used and cannot be found
 	if (!m_plot->plotArea()->backgroundFileName().isEmpty() && !QFile::exists(m_plot->plotArea()->backgroundFileName()))
 		ui.leBackgroundFileName->setStyleSheet("QLineEdit{background:red;}");
 	else
 		ui.leBackgroundFileName->setStyleSheet("");
 
 	//Padding
 	ui.sbPaddingHorizontal->setValue( Worksheet::convertFromSceneUnits(m_plot->horizontalPadding(), Worksheet::Centimeter) );
 	ui.sbPaddingVertical->setValue( Worksheet::convertFromSceneUnits(m_plot->verticalPadding(), Worksheet::Centimeter) );
 
 	//Border
 	ui.kcbBorderColor->setColor( m_plot->plotArea()->borderPen().color() );
 	ui.cbBorderStyle->setCurrentIndex( (int) m_plot->plotArea()->borderPen().style() );
 	ui.sbBorderWidth->setValue( Worksheet::convertFromSceneUnits(m_plot->plotArea()->borderPen().widthF(), Worksheet::Point) );
 	ui.sbBorderCornerRadius->setValue( Worksheet::convertFromSceneUnits(m_plot->plotArea()->borderCornerRadius(), Worksheet::Centimeter) );
 	ui.sbBorderOpacity->setValue( round(m_plot->plotArea()->borderOpacity()*100) );
 	GuiTools::updatePenStyles(ui.cbBorderStyle, ui.kcbBorderColor->color());
 }
 
 void CartesianPlotDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group("CartesianPlot");
 
 	//General
 	//we don't load/save the settings in the general-tab, since they are not style related.
 	//It doesn't make sense to load/save them in the template.
 	//This data is read in CartesianPlotDock::setPlots().
 
 	//Title
 	KConfigGroup plotTitleGroup = config.group("CartesianPlotTitle");
 	labelWidget->loadConfig(plotTitleGroup);
 
 	//Scale breakings
 	//TODO
 
 	//Background-tab
 	ui.cbBackgroundType->setCurrentIndex( group.readEntry("BackgroundType", (int) m_plot->plotArea()->backgroundType()) );
 	ui.cbBackgroundColorStyle->setCurrentIndex( group.readEntry("BackgroundColorStyle", (int) m_plot->plotArea()->backgroundColorStyle()) );
 	ui.cbBackgroundImageStyle->setCurrentIndex( group.readEntry("BackgroundImageStyle", (int) m_plot->plotArea()->backgroundImageStyle()) );
 	ui.cbBackgroundBrushStyle->setCurrentIndex( group.readEntry("BackgroundBrushStyle", (int) m_plot->plotArea()->backgroundBrushStyle()) );
 	ui.leBackgroundFileName->setText( group.readEntry("BackgroundFileName", m_plot->plotArea()->backgroundFileName()) );
 	ui.kcbBackgroundFirstColor->setColor( group.readEntry("BackgroundFirstColor", m_plot->plotArea()->backgroundFirstColor()) );
 	ui.kcbBackgroundSecondColor->setColor( group.readEntry("BackgroundSecondColor", m_plot->plotArea()->backgroundSecondColor()) );
 	ui.sbBackgroundOpacity->setValue( round(group.readEntry("BackgroundOpacity", m_plot->plotArea()->backgroundOpacity())*100.0) );
 	ui.sbPaddingHorizontal->setValue(Worksheet::convertFromSceneUnits(group.readEntry("HorizontalPadding", m_plot->horizontalPadding()), Worksheet::Centimeter));
 	ui.sbPaddingVertical->setValue(Worksheet::convertFromSceneUnits(group.readEntry("VerticalPadding", m_plot->verticalPadding()), Worksheet::Centimeter));
 
 	//Border-tab
 	ui.kcbBorderColor->setColor( group.readEntry("BorderColor", m_plot->plotArea()->borderPen().color()) );
 	ui.cbBorderStyle->setCurrentIndex( group.readEntry("BorderStyle", (int) m_plot->plotArea()->borderPen().style()) );
 	ui.sbBorderWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("BorderWidth", m_plot->plotArea()->borderPen().widthF()), Worksheet::Point) );
 	ui.sbBorderCornerRadius->setValue( Worksheet::convertFromSceneUnits(group.readEntry("BorderCornerRadius", m_plot->plotArea()->borderCornerRadius()), Worksheet::Centimeter) );
 	ui.sbBorderOpacity->setValue( group.readEntry("BorderOpacity", m_plot->plotArea()->borderOpacity())*100 );
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbBorderStyle, ui.kcbBorderColor->color());
 	m_initializing = false;
 }
 
 void CartesianPlotDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group("CartesianPlot");
 
 	//General
 	//we don't load/save the settings in the general-tab, since they are not style related.
 	//It doesn't make sense to load/save them in the template.
 
 	//Title
 	KConfigGroup plotTitleGroup = config.group("CartesianPlotTitle");
 	labelWidget->saveConfig(plotTitleGroup);
 
 	//Scale breakings
 	//TODO
 
 	//Background
 	group.writeEntry("BackgroundType", ui.cbBackgroundType->currentIndex());
 	group.writeEntry("BackgroundColorStyle", ui.cbBackgroundColorStyle->currentIndex());
 	group.writeEntry("BackgroundImageStyle", ui.cbBackgroundImageStyle->currentIndex());
 	group.writeEntry("BackgroundBrushStyle", ui.cbBackgroundBrushStyle->currentIndex());
 	group.writeEntry("BackgroundFileName", ui.leBackgroundFileName->text());
 	group.writeEntry("BackgroundFirstColor", ui.kcbBackgroundFirstColor->color());
 	group.writeEntry("BackgroundSecondColor", ui.kcbBackgroundSecondColor->color());
 	group.writeEntry("BackgroundOpacity", ui.sbBackgroundOpacity->value()/100.0);
 	group.writeEntry("HorizontalPadding", Worksheet::convertToSceneUnits(ui.sbPaddingHorizontal->value(), Worksheet::Centimeter));
 	group.writeEntry("VerticalPadding", Worksheet::convertToSceneUnits(ui.sbPaddingVertical->value(), Worksheet::Centimeter));
 
 	//Border
 	group.writeEntry("BorderStyle", ui.cbBorderStyle->currentIndex());
 	group.writeEntry("BorderColor", ui.kcbBorderColor->color());
 	group.writeEntry("BorderWidth", Worksheet::convertToSceneUnits(ui.sbBorderWidth->value(), Worksheet::Point));
 	group.writeEntry("BorderCornerRadius", Worksheet::convertToSceneUnits(ui.sbBorderCornerRadius->value(), Worksheet::Centimeter));
 	group.writeEntry("BorderOpacity", ui.sbBorderOpacity->value()/100.0);
 
 	config.sync();
 }
 
 void CartesianPlotDock::loadTheme(const QString& theme) {
-	for (auto* plot: m_plotList)
+	for (auto* plot : m_plotList)
 		plot->setTheme(theme);
 }
 
 void CartesianPlotDock::saveTheme(KConfig& config) const {
 	if(!m_plotList.isEmpty())
 		m_plotList.at(0)->saveTheme(config);
 }
diff --git a/src/kdefrontend/dockwidgets/ColumnDock.cpp b/src/kdefrontend/dockwidgets/ColumnDock.cpp
index a91a73cb6..9e3564697 100644
--- a/src/kdefrontend/dockwidgets/ColumnDock.cpp
+++ b/src/kdefrontend/dockwidgets/ColumnDock.cpp
@@ -1,423 +1,423 @@
 /***************************************************************************
     File                 : ColumnDock.cpp
     Project              : LabPlot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2017 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2013-2017 by Stefan Gerlach (stefan.gerlach@uni.kn)
     Description          : widget for column properties
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ColumnDock.h"
 
 #include "backend/core/AbstractFilter.h"
 #include "backend/core/datatypes/SimpleCopyThroughFilter.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/String2DoubleFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/core/datatypes/String2DateTimeFilter.h"
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 
 #include <KLocalizedString>
 
 /*!
   \class ColumnDock
   \brief Provides a widget for editing the properties of the spreadsheet columns currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 
 ColumnDock::ColumnDock(QWidget* parent) : QWidget(parent), m_column(nullptr), m_initializing(false) {
 	ui.setupUi(this);
 
 	connect(ui.leName, &QLineEdit::textChanged, this, &ColumnDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &ColumnDock::commentChanged);
 	connect(ui.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
 	connect(ui.cbFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(formatChanged(int)));
 	connect(ui.sbPrecision, SIGNAL(valueChanged(int)), this, SLOT(precisionChanged(int)) );
 	connect(ui.cbPlotDesignation, SIGNAL(currentIndexChanged(int)), this, SLOT(plotDesignationChanged(int)));
 
 	retranslateUi();
 }
 
 void ColumnDock::setColumns(QList<Column*> list) {
 	m_initializing = true;
 	m_columnsList = list;
 	m_column = list.first();
 
 	//check whether we have non-editable columns (e.g. columns for residuals calculated in XYFitCurve)
 	bool nonEditable = false;
-	for (auto* col: m_columnsList) {
-		const auto s = dynamic_cast<Spreadsheet*>(col->parentAspect());
+	for (auto* col : m_columnsList) {
+		auto* s = dynamic_cast<Spreadsheet*>(col->parentAspect());
 		if (s) {
 			if (dynamic_cast<LiveDataSource*>(s)) {
 				nonEditable = true;
 				break;
 			}
 		} else {
 			nonEditable = true;
 			break;
 		}
 	}
 
 	if (list.size() == 1) {
 		//names and comments of non-editable columns in a file data source can be changed.
 		if (!nonEditable && dynamic_cast<LiveDataSource*>(m_column->parentAspect()) != nullptr) {
 			ui.leName->setEnabled(false);
 			ui.leComment->setEnabled(false);
 		} else {
 			ui.leName->setEnabled(true);
 			ui.leComment->setEnabled(true);
 		}
 
 		ui.leName->setText(m_column->name());
 		ui.leComment->setText(m_column->comment());
 	} else {
 		ui.leName->setEnabled(false);
 		ui.leComment->setEnabled(false);
 
 		ui.leName->setText("");
 		ui.leComment->setText("");
 	}
 
 	//show the properties of the first column
 	AbstractColumn::ColumnMode columnMode = m_column->columnMode();
 	ui.cbType->setCurrentIndex(ui.cbType->findData((int)columnMode));
 
 	//disable widgets if we have at least one non-editable column
 	ui.cbType->setEnabled(!nonEditable);
 	ui.lFormat->setVisible(!nonEditable);
 	ui.cbFormat->setVisible(!nonEditable);
 	ui.lPrecision->setVisible(!nonEditable);
 	ui.sbPrecision->setVisible(!nonEditable);
 	ui.lPlotDesignation->setVisible(!nonEditable);
 	ui.cbPlotDesignation->setVisible(!nonEditable);
 	if (nonEditable) {
 		m_initializing = false;
 		return;
 	}
 
 	this->updateFormatWidgets(columnMode);
 
 	switch(columnMode) {
 	case AbstractColumn::Numeric: {
-			auto filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
+			auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->numericFormat()));
 			ui.sbPrecision->setValue(filter->numDigits());
 			break;
 		}
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
-			auto filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
+			auto* filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
 			DEBUG("	set column format: " << filter->format().toStdString());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->format()));
 			break;
 		}
 	case AbstractColumn::Integer:	// nothing to set
 	case AbstractColumn::Text:
 		break;
 	}
 
 	ui.cbPlotDesignation->setCurrentIndex( int(m_column->plotDesignation()) );
 
 	// slots
 	connect(m_column, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),this, SLOT(columnDescriptionChanged(const AbstractAspect*)));
 	connect(m_column->outputFilter(), SIGNAL(formatChanged()),this, SLOT(columnFormatChanged()));
 	connect(m_column->outputFilter(), SIGNAL(digitsChanged()),this, SLOT(columnPrecisionChanged()));
 	connect(m_column, SIGNAL(plotDesignationChanged(const AbstractColumn*)),this, SLOT(columnPlotDesignationChanged(const AbstractColumn*)));
 
 	m_initializing = false;
 }
 
 /*!
   depending on the currently selected column type (column mode) updates the widgets for the column format,
   shows/hides the allowed widgets, fills the corresponding combobox with the possible entries.
   Called when the type (column mode) is changed.
 */
 void ColumnDock::updateFormatWidgets(const AbstractColumn::ColumnMode columnMode) {
 	ui.cbFormat->clear();
 
 	switch (columnMode) {
 	case AbstractColumn::Numeric:
 		ui.cbFormat->addItem(i18n("Decimal"), QVariant('f'));
 		ui.cbFormat->addItem(i18n("Scientific (e)"), QVariant('e'));
 		ui.cbFormat->addItem(i18n("Scientific (E)"), QVariant('E'));
 		ui.cbFormat->addItem(i18n("Automatic (g)"), QVariant('g'));
 		ui.cbFormat->addItem(i18n("Automatic (G)"), QVariant('G'));
 		break;
 	case AbstractColumn::Month:
 		ui.cbFormat->addItem(i18n("Number without Leading Zero"), QVariant("M"));
 		ui.cbFormat->addItem(i18n("Number with Leading Zero"), QVariant("MM"));
 		ui.cbFormat->addItem(i18n("Abbreviated Month Name"), QVariant("MMM"));
 		ui.cbFormat->addItem(i18n("Full Month Name"), QVariant("MMMM"));
 		break;
 	case AbstractColumn::Day:
 		ui.cbFormat->addItem(i18n("Number without Leading Zero"), QVariant("d"));
 		ui.cbFormat->addItem(i18n("Number with Leading Zero"), QVariant("dd"));
 		ui.cbFormat->addItem(i18n("Abbreviated Day Name"), QVariant("ddd"));
 		ui.cbFormat->addItem(i18n("Full Day Name"), QVariant("dddd"));
 		break;
 	case AbstractColumn::DateTime:
-		for (const auto& s: AbstractColumn::dateTimeFormats())
+		for (const auto& s : AbstractColumn::dateTimeFormats())
 			ui.cbFormat->addItem(s, QVariant(s));
 		break;
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	}
 
 	if (columnMode == AbstractColumn::Numeric) {
 		ui.lPrecision->show();
 		ui.sbPrecision->show();
 	} else {
 		ui.lPrecision->hide();
 		ui.sbPrecision->hide();
 	}
 
 	if (columnMode == AbstractColumn::Text || columnMode == AbstractColumn::Integer) {
 		ui.lFormat->hide();
 		ui.cbFormat->hide();
 	} else {
 		ui.lFormat->show();
 		ui.cbFormat->show();
 	}
 
 	if (columnMode == AbstractColumn::DateTime) {
 		ui.cbFormat->setEditable(true);
 		ui.cbFormat->setCurrentItem("yyyy-MM-dd hh:mm:ss.zzz");
 	} else {
 		ui.cbFormat->setEditable(false);
 		ui.cbFormat->setCurrentIndex(0);
 	}
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in ColumnDock **********
 //*************************************************************
 void ColumnDock::retranslateUi() {
 	m_initializing = true;
 
 	ui.cbType->clear();
 	ui.cbType->addItem(i18n("Numeric"), QVariant(int(AbstractColumn::Numeric)));
 	ui.cbType->addItem(i18n("Integer"), QVariant(int(AbstractColumn::Integer)));
 	ui.cbType->addItem(i18n("Text"), QVariant(int(AbstractColumn::Text)));
 	ui.cbType->addItem(i18n("Month Names"), QVariant(int(AbstractColumn::Month)));
 	ui.cbType->addItem(i18n("Day Names"), QVariant(int(AbstractColumn::Day)));
 	ui.cbType->addItem(i18n("Date and Time"), QVariant(int(AbstractColumn::DateTime)));
 
 	ui.cbPlotDesignation->clear();
 	ui.cbPlotDesignation->addItem(i18n("None"));
 	ui.cbPlotDesignation->addItem(i18n("X"));
 	ui.cbPlotDesignation->addItem(i18n("Y"));
 	ui.cbPlotDesignation->addItem(i18n("Z"));
 	ui.cbPlotDesignation->addItem(i18n("X-error"));
 	ui.cbPlotDesignation->addItem(i18n("X-error -"));
 	ui.cbPlotDesignation->addItem(i18n("X-error +"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error -"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error +"));
 
 	m_initializing = false;
 }
 
 void ColumnDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_columnsList.first()->setName(ui.leName->text());
 }
 
 void ColumnDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_columnsList.first()->setComment(ui.leComment->text());
 }
 
 /*!
   called when the type (column mode - numeric, text etc.) of the column was changed.
 */
 void ColumnDock::typeChanged(int index) {
 	DEBUG("ColumnDock::typeChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractColumn::ColumnMode columnMode = (AbstractColumn::ColumnMode)ui.cbType->itemData(index).toInt();
 	int format_index = ui.cbFormat->currentIndex();
 
 	m_initializing = true;
 	this->updateFormatWidgets(columnMode);
 	m_initializing = false;
 
 	switch(columnMode) {
 	case AbstractColumn::Numeric: {
 			int digits = ui.sbPrecision->value();
-			for (auto* col: m_columnsList) {
+			for (auto* col : m_columnsList) {
 				col->beginMacro(i18n("%1: change column type", col->name()));
 				col->setColumnMode(columnMode);
-				auto filter = static_cast<Double2StringFilter*>(col->outputFilter());
+				auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 				filter->setNumericFormat(ui.cbFormat->itemData(format_index).toChar().toLatin1());
 				filter->setNumDigits(digits);
 				col->endMacro();
 			}
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
-		for (auto* col: m_columnsList)
+		for (auto* col : m_columnsList)
 			col->setColumnMode(columnMode);
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
-		for (auto* col: m_columnsList) {
+		for (auto* col : m_columnsList) {
 			col->beginMacro(i18n("%1: change column type", col->name()));
 			// the format is saved as item data
 			QString format = ui.cbFormat->itemData(ui.cbFormat->currentIndex()).toString();
 			col->setColumnMode(columnMode);
-			auto filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
+			auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			col->endMacro();
 		}
 		break;
 	case AbstractColumn::DateTime:
-		for (auto* col: m_columnsList) {
+		for (auto* col : m_columnsList) {
 			col->beginMacro(i18n("%1: change column type", col->name()));
 			// the format is the current text
 			QString format = ui.cbFormat->currentText();
 			col->setColumnMode(columnMode);
-			auto filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
+			auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			col->endMacro();
 		}
 		break;
 	}
 	DEBUG("ColumnDock::typeChanged() DONE");
 }
 
 /*!
   called when the format for the current type (column mode) was changed.
 */
 void ColumnDock::formatChanged(int index) {
 	DEBUG("ColumnDock::formatChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractColumn::ColumnMode mode = (AbstractColumn::ColumnMode)ui.cbType->itemData(ui.cbType->currentIndex()).toInt();
 	int format_index = index;
 
 	switch(mode) {
 	case AbstractColumn::Numeric: {
-			for (auto* col: m_columnsList) {
-				auto filter = static_cast<Double2StringFilter*>(col->outputFilter());
+			for (auto* col : m_columnsList) {
+				auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 				filter->setNumericFormat(ui.cbFormat->itemData(format_index).toChar().toLatin1());
 			}
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
 			QString format = ui.cbFormat->itemData(ui.cbFormat->currentIndex()).toString();
-			for (auto* col: m_columnsList) {
-				auto filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
+			for (auto* col : m_columnsList) {
+				auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 				filter->setFormat(format);
 			}
 			break;
 		}
 	}
 	DEBUG("ColumnDock::formatChanged() DONE");
 }
 
 void ColumnDock::precisionChanged(int digits) {
 	if (m_initializing)
 		return;
 
-	for (auto* col: m_columnsList) {
-		auto filter = static_cast<Double2StringFilter*>(col->outputFilter());
+	for (auto* col : m_columnsList) {
+		auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 		filter->setNumDigits(digits);
 	}
 }
 
 void ColumnDock::plotDesignationChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto pd = AbstractColumn::PlotDesignation(index);
-	for (auto* col: m_columnsList)
+	for (auto* col : m_columnsList)
 		col->setPlotDesignation(pd);
 }
 
 //*************************************************************
 //********* SLOTs for changes triggered in Column *************
 //*************************************************************
 void ColumnDock::columnDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_column != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.leComment->text())
 		ui.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void ColumnDock::columnFormatChanged() {
 	DEBUG("ColumnDock::columnFormatChanged()");
 	m_initializing = true;
 	AbstractColumn::ColumnMode columnMode = m_column->columnMode();
 	switch(columnMode) {
 	case AbstractColumn::Numeric: {
-			auto filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
+			auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->numericFormat()));
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
-			auto filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
+			auto* filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->format()));
 			break;
 		}
 	}
 	m_initializing = false;
 }
 
 void ColumnDock::columnPrecisionChanged() {
 	m_initializing = true;
-	auto filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
+	auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 	ui.sbPrecision->setValue(filter->numDigits());
 	m_initializing = false;
 }
 
 void ColumnDock::columnPlotDesignationChanged(const AbstractColumn* col) {
 	m_initializing = true;
 	ui.cbPlotDesignation->setCurrentIndex( int(col->plotDesignation()) );
 	m_initializing = false;
 }
diff --git a/src/kdefrontend/dockwidgets/CustomPointDock.cpp b/src/kdefrontend/dockwidgets/CustomPointDock.cpp
index 960946d4f..a93865a4d 100644
--- a/src/kdefrontend/dockwidgets/CustomPointDock.cpp
+++ b/src/kdefrontend/dockwidgets/CustomPointDock.cpp
@@ -1,503 +1,503 @@
 /***************************************************************************
     File                 : CustomPointDock.cpp
     Project              : LabPlot
     Description          : widget for Datapicker-Point properties
     --------------------------------------------------------------------
     Copyright            : (C) 2015 Alexander Semke (alexander.semke@web.de)
  ***************************************************************************/
 /***************************************************************************
  *                                                                         *
  *  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 "CustomPointDock.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CustomPoint.h"
 
 #include "kdefrontend/TemplateHandler.h"
 #include "kdefrontend/GuiTools.h"
 
 #include <QPainter>
 #include <QDir>
 #include <KLocalizedString>
 #include <KConfig>
 #include <KConfigGroup>
 
 CustomPointDock::CustomPointDock(QWidget *parent): QWidget(parent), m_point(nullptr) {
 	ui.setupUi(this);
 
 	//Validators
 	ui.lePositionX->setValidator( new QDoubleValidator(ui.lePositionX) );
 	ui.lePositionY->setValidator( new QDoubleValidator(ui.lePositionY) );
 
 	//adjust layouts in the tabs
 	for (int i = 0; i < ui.tabWidget->count(); ++i) {
-	  auto layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
-	  if (!layout)
-		continue;
+		auto* layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
+		if (!layout)
+			continue;
 
-	  layout->setContentsMargins(2,2,2,2);
-	  layout->setHorizontalSpacing(2);
-	  layout->setVerticalSpacing(2);
+		layout->setContentsMargins(2,2,2,2);
+		layout->setHorizontalSpacing(2);
+		layout->setVerticalSpacing(2);
 	}
 
 	//SLOTS
 	//General
 	connect(ui.leName, &QLineEdit::textChanged, this, &CustomPointDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &CustomPointDock::commentChanged);
 	connect( ui.lePositionX, SIGNAL(returnPressed()), this, SLOT(positionXChanged()) );
 	connect( ui.lePositionY, SIGNAL(returnPressed()), this, SLOT(positionYChanged()) );
 	connect( ui.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 
 	//Symbols
 	connect( ui.cbSymbolStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolStyleChanged(int)) );
 	connect( ui.sbSymbolSize, SIGNAL(valueChanged(double)), this, SLOT(symbolSizeChanged(double)) );
 	connect( ui.sbSymbolRotation, SIGNAL(valueChanged(int)), this, SLOT(symbolRotationChanged(int)) );
 	connect( ui.sbSymbolOpacity, SIGNAL(valueChanged(int)), this, SLOT(symbolOpacityChanged(int)) );
 	connect( ui.cbSymbolFillingStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolFillingStyleChanged(int)) );
 	connect( ui.kcbSymbolFillingColor, SIGNAL(changed(QColor)), this, SLOT(symbolFillingColorChanged(QColor)) );
 	connect( ui.cbSymbolBorderStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolBorderStyleChanged(int)) );
 	connect( ui.kcbSymbolBorderColor, SIGNAL(changed(QColor)), this, SLOT(symbolBorderColorChanged(QColor)) );
 	connect( ui.sbSymbolBorderWidth, SIGNAL(valueChanged(double)), this, SLOT(symbolBorderWidthChanged(double)) );
 
 	//Template handler
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::CustomPoint);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::CustomPoint);
 	ui.verticalLayout->addWidget(templateHandler);
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 
 	init();
 }
 
 void CustomPointDock::init() {
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, Qt::black);
 
 	QPainter pa;
 	int iconSize = 20;
 	QPixmap pm(iconSize, iconSize);
 	QPen pen(Qt::SolidPattern, 0);
 	ui.cbSymbolStyle->setIconSize(QSize(iconSize, iconSize));
 	QTransform trafo;
 	trafo.scale(15, 15);
 	for (int i=0; i<18; ++i) {
 		auto style = (Symbol::Style)i;
 		pm.fill(Qt::transparent);
 		pa.begin(&pm);
 		pa.setPen( pen );
 		pa.setRenderHint(QPainter::Antialiasing);
 		pa.translate(iconSize/2,iconSize/2);
 		pa.drawPath(trafo.map(Symbol::pathFromStyle(style)));
 		pa.end();
 		ui.cbSymbolStyle->addItem(QIcon(pm), Symbol::nameFromStyle(style));
 	}
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, Qt::black);
 	m_initializing = false;
 }
 
 void CustomPointDock::setPoints(QList<CustomPoint*> list) {
 	m_initializing=true;
 	m_pointsList = list;
 	m_point = list.first();
 	Q_ASSERT(m_point);
 
 	//if there are more then one point in the list, disable the comment and name widgets in the tab "general"
 	if (list.size()==1) {
 		ui.lName->setEnabled(true);
 		ui.leName->setEnabled(true);
 		ui.lComment->setEnabled(true);
 		ui.leComment->setEnabled(true);
 		ui.leName->setText(m_point->name());
 		ui.leComment->setText(m_point->comment());
 	}else{
 		ui.lName->setEnabled(false);
 		ui.leName->setEnabled(false);
 		ui.lComment->setEnabled(false);
 		ui.leComment->setEnabled(false);
 		ui.leName->setText("");
 		ui.leComment->setText("");
 	}
 
 	//show the properties of the first custom point
 	this->load();
 
 	//SIGNALs/SLOTs
 	// general
 	connect(m_point, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),this, SLOT(pointDescriptionChanged(const AbstractAspect*)));
 	connect(m_point, SIGNAL(positionChanged(QPointF)), this, SLOT(pointPositionChanged(QPointF)));
 	connect(m_point, SIGNAL(visibleChanged(bool)), this, SLOT(pointVisibilityChanged(bool)));
 
 	//symbol
 	connect(m_point, SIGNAL(symbolStyleChanged(Symbol::Style)), this, SLOT(pointSymbolStyleChanged(Symbol::Style)));
 	connect(m_point, SIGNAL(symbolSizeChanged(qreal)), this, SLOT(pointSymbolSizeChanged(qreal)));
 	connect(m_point, SIGNAL(symbolRotationAngleChanged(qreal)), this, SLOT(pointSymbolRotationAngleChanged(qreal)));
 	connect(m_point, SIGNAL(symbolOpacityChanged(qreal)), this, SLOT(pointSymbolOpacityChanged(qreal)));
 	connect(m_point, SIGNAL(symbolBrushChanged(QBrush)), this, SLOT(pointSymbolBrushChanged(QBrush)));
 	connect(m_point, SIGNAL(symbolPenChanged(QPen)), this, SLOT(pointSymbolPenChanged(QPen)));
 }
 
 //**********************************************************
 //**** SLOTs for changes triggered in CustomPointDock ******
 //**********************************************************
 //"General"-tab
 void CustomPointDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_point->setName(ui.leName->text());
 }
 
 void CustomPointDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_point->setComment(ui.leComment->text());
 }
 
 void CustomPointDock::positionXChanged() {
 	if (m_initializing)
 		return;
 
 	QPointF pos = m_point->position();
 	float x = ui.lePositionX->text().toFloat();
 	pos.setX(x);
 	for (auto* point : m_pointsList)
 		point->setPosition(pos);
 }
 
 void CustomPointDock::positionYChanged() {
 	if (m_initializing)
 		return;
 
 	QPointF pos = m_point->position();
 	float y = ui.lePositionY->text().toFloat();
 	pos.setY(y);
 	for (auto* point : m_pointsList)
 		point->setPosition(pos);
 }
 
 void CustomPointDock::visibilityChanged(bool state) {
 	if (m_initializing)
 		return;
 
 	m_point->beginMacro(i18n("%1 CustomPoints: visibility changed", m_pointsList.count()));
 	for (auto* point : m_pointsList)
 		point->setVisible(state);
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolStyleChanged(int index) {
 	auto style = Symbol::Style(index);
 	//enable/disable the  filling options in the GUI depending on the currently selected points.
 	if (style != Symbol::Line && style != Symbol::Cross) {
 		ui.cbSymbolFillingStyle->setEnabled(true);
 		bool noBrush = (Qt::BrushStyle(ui.cbSymbolFillingStyle->currentIndex())==Qt::NoBrush);
 		ui.kcbSymbolFillingColor->setEnabled(!noBrush);
 	} else {
 		ui.kcbSymbolFillingColor->setEnabled(false);
 		ui.cbSymbolFillingStyle->setEnabled(false);
 	}
 
 	bool noLine = (Qt::PenStyle(ui.cbSymbolBorderStyle->currentIndex())== Qt::NoPen);
 	ui.kcbSymbolBorderColor->setEnabled(!noLine);
 	ui.sbSymbolBorderWidth->setEnabled(!noLine);
 
 	if (m_initializing)
 		return;
 
 	m_point->beginMacro(i18n("%1 CustomPoints: style changed", m_pointsList.count()));
 	for (auto* point : m_pointsList)
 		point->setSymbolStyle(style);
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolSizeChanged(double value) {
 	if (m_initializing)
 		return;
 
 	m_point->beginMacro(i18n("%1 CustomPoints: size changed", m_pointsList.count()));
 	for (auto* point : m_pointsList)
 		point->setSymbolSize( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolRotationChanged(int value) {
 	if (m_initializing)
 		return;
 
 	m_point->beginMacro(i18n("%1 CustomPoints: rotation changed", m_pointsList.count()));
 	for (auto* point : m_pointsList)
 		point->setSymbolRotationAngle(value);
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	m_point->beginMacro(i18n("%1 CustomPoints: opacity changed", m_pointsList.count()));
 	for (auto* point : m_pointsList)
 		point->setSymbolOpacity(opacity);
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolFillingStyleChanged(int index) {
 	auto brushStyle = Qt::BrushStyle(index);
 	ui.kcbSymbolFillingColor->setEnabled(!(brushStyle==Qt::NoBrush));
 
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	m_point->beginMacro(i18n("%1 CustomPoints: filling style changed", m_pointsList.count()));
 	for (auto* point : m_pointsList) {
 		brush = point->symbolBrush();
 		brush.setStyle(brushStyle);
 		point->setSymbolBrush(brush);
 	}
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolFillingColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	m_point->beginMacro(i18n("%1 CustomPoints: filling color changed", m_pointsList.count()));
 	for (auto* point : m_pointsList) {
 		brush = point->symbolBrush();
 		brush.setColor(color);
 		point->setSymbolBrush(brush);
 	}
 	m_point->endMacro();
 
 	m_initializing = true;
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, color );
 	m_initializing = false;
 }
 
 void CustomPointDock::symbolBorderStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	if ( penStyle == Qt::NoPen ) {
 		ui.kcbSymbolBorderColor->setEnabled(false);
 		ui.sbSymbolBorderWidth->setEnabled(false);
 	} else {
 		ui.kcbSymbolBorderColor->setEnabled(true);
 		ui.sbSymbolBorderWidth->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	m_point->beginMacro(i18n("%1 CustomPoints: border style changed", m_pointsList.count()));
 	for (auto* point : m_pointsList) {
 		pen = point->symbolPen();
 		pen.setStyle(penStyle);
 		point->setSymbolPen(pen);
 	}
 	m_point->endMacro();
 }
 
 void CustomPointDock::symbolBorderColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	m_point->beginMacro(i18n("%1 CustomPoints: border color changed", m_pointsList.count()));
 	for (auto* point : m_pointsList) {
 		pen = point->symbolPen();
 		pen.setColor(color);
 		point->setSymbolPen(pen);
 	}
 	m_point->endMacro();
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, color);
 	m_initializing = false;
 }
 
 void CustomPointDock::symbolBorderWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	m_point->beginMacro(i18n("%1 CustomPoints: border width changed", m_pointsList.count()));
 	for (auto* point : m_pointsList) {
 		pen = point->symbolPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		point->setSymbolPen(pen);
 	}
 	m_point->endMacro();
 }
 
 //*********************************************************
 //**** SLOTs for changes triggered in CustomPoint *********
 //*********************************************************
 //"General"-tab
 void CustomPointDock::pointDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_point != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text()) {
 		ui.leName->setText(aspect->name());
 	} else if (aspect->comment() != ui.leComment->text()) {
 		ui.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void CustomPointDock::pointPositionChanged(QPointF position) {
 	m_initializing = true;
 	ui.lePositionX->setText(QString::number(position.x()));
 	ui.lePositionY->setText(QString::number(position.y()));
 	m_initializing = false;
 }
 
 //"Symbol"-tab
 void CustomPointDock::pointSymbolStyleChanged(Symbol::Style style) {
 	m_initializing = true;
 	ui.cbSymbolStyle->setCurrentIndex((int)style);
 	m_initializing = false;
 }
 
 void CustomPointDock::pointSymbolSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 
 void CustomPointDock::pointSymbolRotationAngleChanged(qreal angle) {
 	m_initializing = true;
 	ui.sbSymbolRotation->setValue(qRound(angle));
 	m_initializing = false;
 }
 
 void CustomPointDock::pointSymbolOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbSymbolOpacity->setValue( qRound(opacity*100.0) );
 	m_initializing = false;
 }
 
 void CustomPointDock::pointSymbolBrushChanged(const QBrush& brush) {
 	m_initializing = true;
 	ui.cbSymbolFillingStyle->setCurrentIndex((int) brush.style());
 	ui.kcbSymbolFillingColor->setColor(brush.color());
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, brush.color());
 	m_initializing = false;
 }
 
 void CustomPointDock::pointSymbolPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbSymbolBorderStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbSymbolBorderColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, pen.color());
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(), Worksheet::Point));
 	m_initializing = false;
 }
 
 void CustomPointDock::pointVisibilityChanged(bool on) {
 	m_initializing = true;
 	ui.chkVisible->setChecked(on);
 	m_initializing = false;
 }
 
 //**********************************************************
 //******************** SETTINGS ****************************
 //**********************************************************
 void CustomPointDock::load() {
 	if (!m_point)
 		return;
 
 	m_initializing = true;
 
 	ui.lePositionX->setText(QString::number(m_point->position().x()));
 	ui.lePositionY->setText(QString::number(m_point->position().y()));
 
 	ui.cbSymbolStyle->setCurrentIndex( (int)m_point->symbolStyle() );
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(m_point->symbolSize(), Worksheet::Point) );
 	ui.sbSymbolRotation->setValue( m_point->symbolRotationAngle() );
 	ui.sbSymbolOpacity->setValue( qRound(m_point->symbolOpacity()*100.0) );
 
 	ui.cbSymbolFillingStyle->setCurrentIndex( (int) m_point->symbolBrush().style() );
 	ui.kcbSymbolFillingColor->setColor(  m_point->symbolBrush().color() );
 
 	ui.cbSymbolBorderStyle->setCurrentIndex( (int) m_point->symbolPen().style() );
 	ui.kcbSymbolBorderColor->setColor( m_point->symbolPen().color() );
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(m_point->symbolPen().widthF(), Worksheet::Point) );
 
 	ui.chkVisible->setChecked( m_point->isVisible() );
 
 	m_initializing = false;
 }
 
 void CustomPointDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index!=-1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	int size = m_pointsList.size();
 	if (size>1)
 		m_point->beginMacro(i18n("%1 custom points: template \"%2\" loaded", size, name));
 	else
 		m_point->beginMacro(i18n("%1: template \"%2\" loaded", m_point->name(), name));
 
 	this->loadConfig(config);
 
 	m_point->endMacro();
 }
 
 void CustomPointDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group( "CustomPoint" );
 
 	ui.cbSymbolStyle->setCurrentIndex( group.readEntry("SymbolStyle", (int)m_point->symbolStyle()) );
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolSize", m_point->symbolSize()), Worksheet::Point) );
 	ui.sbSymbolRotation->setValue( group.readEntry("SymbolRotation", m_point->symbolRotationAngle()) );
 	ui.sbSymbolOpacity->setValue( qRound(group.readEntry("SymbolOpacity", m_point->symbolOpacity())*100.0) );
 	ui.cbSymbolFillingStyle->setCurrentIndex( group.readEntry("SymbolFillingStyle", (int) m_point->symbolBrush().style()) );
 	ui.kcbSymbolFillingColor->setColor(  group.readEntry("SymbolFillingColor", m_point->symbolBrush().color()) );
 	ui.cbSymbolBorderStyle->setCurrentIndex( group.readEntry("SymbolBorderStyle", (int) m_point->symbolPen().style()) );
 	ui.kcbSymbolBorderColor->setColor( group.readEntry("SymbolBorderColor", m_point->symbolPen().color()) );
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolBorderWidth",m_point->symbolPen().widthF()), Worksheet::Point) );
 
 	m_initializing=true;
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, ui.kcbSymbolFillingColor->color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, ui.kcbSymbolBorderColor->color());
 	m_initializing=false;
 }
 
 void CustomPointDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "CustomPoint" );
 	group.writeEntry("SymbolStyle", ui.cbSymbolStyle->currentText());
 	group.writeEntry("SymbolSize", Worksheet::convertToSceneUnits(ui.sbSymbolSize->value(),Worksheet::Point));
 	group.writeEntry("SymbolRotation", ui.sbSymbolRotation->value());
 	group.writeEntry("SymbolOpacity", ui.sbSymbolOpacity->value()/100 );
 	group.writeEntry("SymbolFillingStyle", ui.cbSymbolFillingStyle->currentIndex());
 	group.writeEntry("SymbolFillingColor", ui.kcbSymbolFillingColor->color());
 	group.writeEntry("SymbolBorderStyle", ui.cbSymbolBorderStyle->currentIndex());
 	group.writeEntry("SymbolBorderColor", ui.kcbSymbolBorderColor->color());
 	group.writeEntry("SymbolBorderWidth", Worksheet::convertToSceneUnits(ui.sbSymbolBorderWidth->value(),Worksheet::Point));
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/HistogramDock.cpp b/src/kdefrontend/dockwidgets/HistogramDock.cpp
index c6f4a0adf..41913b723 100644
--- a/src/kdefrontend/dockwidgets/HistogramDock.cpp
+++ b/src/kdefrontend/dockwidgets/HistogramDock.cpp
@@ -1,1731 +1,1731 @@
 /***************************************************************************
     File                 : HistogramDock.cpp
     Project              : LabPlot
     Description          : widget for Histogram properties
     --------------------------------------------------------------------
     Copyright            : (C) 2016 Anu Mittal (anu22mittal@gmail.com)
     Copyright            : (C) 2018 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "HistogramDock.h"
 #include "backend/worksheet/plots/cartesian/Histogram.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/Symbol.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/TemplateHandler.h"
 #include "kdefrontend/GuiTools.h"
 
 #include <QCompleter>
 #include <QDir>
 #include <QDirModel>
 #include <QFileDialog>
 #include <QImageReader>
 #include <QPainter>
 
 #include <KConfigGroup>
 #include <KConfig>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 /*!
   \class HistogramDock
   \brief  Provides a widget for editing the properties of the Histograms (2D-curves) currently selected in the project explorer.
 
   If more than one curves are set, the properties of the first column are shown. The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 HistogramDock::HistogramDock(QWidget* parent) : QWidget(parent),
 	cbDataColumn(new TreeViewComboBox),
 	m_curve(nullptr),
 	m_aspectTreeModel(nullptr),
 	m_initializing(false) {
 
 	ui.setupUi(this);
 
 	// Tab "General"
-	auto gridLayout = qobject_cast<QGridLayout*>(ui.tabGeneral->layout());
+	auto* gridLayout = qobject_cast<QGridLayout*>(ui.tabGeneral->layout());
 	gridLayout->addWidget(cbDataColumn, 3, 2, 1, 1);
 
 	//Tab "Values"
 	gridLayout = qobject_cast<QGridLayout*>(ui.tabValues->layout());
 	cbValuesColumn = new TreeViewComboBox(ui.tabValues);
 	gridLayout->addWidget(cbValuesColumn, 2, 2, 1, 1);
 
 	//Tab "Filling"
 	ui.cbFillingColorStyle->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
 	ui.bFillingOpen->setIcon( QIcon::fromTheme("document-open") );
 
-	auto completer = new QCompleter(this);
+	auto* completer = new QCompleter(this);
 	completer->setModel(new QDirModel);
 	ui.leFillingFileName->setCompleter(completer);
 
 	//adjust layouts in the tabs
 	for (int i = 0; i < ui.tabWidget->count(); ++i){
-		auto layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
+		auto* layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
 		if (!layout)
 			continue;
 
 		layout->setContentsMargins(2,2,2,2);
 		layout->setHorizontalSpacing(2);
 		layout->setVerticalSpacing(2);
 	}
 
 	ui.leBinWidth->setValidator(new QDoubleValidator(ui.leBinWidth));
 	ui.leBinRangesMin->setValidator(new QDoubleValidator(ui.leBinRangesMin));
 	ui.leBinRangesMax->setValidator(new QDoubleValidator(ui.leBinRangesMax));
 
 	//Slots
 	//General
 	connect(ui.leName, &QLineEdit::textChanged, this, &HistogramDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &HistogramDock::commentChanged);
 	connect( ui.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( cbDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataColumnChanged(QModelIndex)) );
 	connect( ui.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)) );
 	connect( ui.cbOrientation, SIGNAL(currentIndexChanged(int)), this, SLOT(orientationChanged(int)));
 	connect( ui.cbBinningMethod, SIGNAL(currentIndexChanged(int)), this, SLOT(binningMethodChanged(int)) );
 	connect(ui.sbBinCount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &HistogramDock::binCountChanged);
 	connect(ui.leBinWidth, &QLineEdit::textChanged, this, &HistogramDock::binWidthChanged);
 	connect( ui.chkAutoBinRanges, &QCheckBox::stateChanged, this, &HistogramDock::autoBinRangesChanged );
 	connect( ui.leBinRangesMin, &QLineEdit::textChanged, this, &HistogramDock::binRangesMinChanged );
 	connect( ui.leBinRangesMax, &QLineEdit::textChanged, this, &HistogramDock::binRangesMaxChanged );
 
 	//Line
 	connect(ui.cbLineType, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &HistogramDock::lineTypeChanged);
 	connect(ui.cbLineStyle, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &HistogramDock::lineStyleChanged);
 	connect(ui.kcbLineColor, &KColorButton::changed, this, &HistogramDock::lineColorChanged);
 	connect(ui.sbLineWidth, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &HistogramDock::lineWidthChanged);
 	connect(ui.sbLineOpacity, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &HistogramDock::lineOpacityChanged);
 
 	//Symbol
 	connect( ui.cbSymbolStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsStyleChanged(int)) );
 	connect( ui.sbSymbolSize, SIGNAL(valueChanged(double)), this, SLOT(symbolsSizeChanged(double)) );
 	connect( ui.sbSymbolRotation, SIGNAL(valueChanged(int)), this, SLOT(symbolsRotationChanged(int)) );
 	connect( ui.sbSymbolOpacity, SIGNAL(valueChanged(int)), this, SLOT(symbolsOpacityChanged(int)) );
 
 	connect( ui.cbSymbolFillingStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsFillingStyleChanged(int)) );
 	connect( ui.kcbSymbolFillingColor, SIGNAL(changed(QColor)), this, SLOT(symbolsFillingColorChanged(QColor)) );
 
 	connect( ui.cbSymbolBorderStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsBorderStyleChanged(int)) );
 	connect( ui.kcbSymbolBorderColor, SIGNAL(changed(QColor)), this, SLOT(symbolsBorderColorChanged(QColor)) );
 	connect( ui.sbSymbolBorderWidth, SIGNAL(valueChanged(double)), this, SLOT(symbolsBorderWidthChanged(double)) );
 
 	//Values
 	connect( ui.cbValuesType, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesTypeChanged(int)) );
 	connect( cbValuesColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(valuesColumnChanged(QModelIndex)) );
 	connect( ui.cbValuesPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesPositionChanged(int)) );
 	connect( ui.sbValuesDistance, SIGNAL(valueChanged(double)), this, SLOT(valuesDistanceChanged(double)) );
 	connect( ui.sbValuesRotation, SIGNAL(valueChanged(int)), this, SLOT(valuesRotationChanged(int)) );
 	connect( ui.sbValuesOpacity, SIGNAL(valueChanged(int)), this, SLOT(valuesOpacityChanged(int)) );
 
 	//TODO connect( ui.cbValuesFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesColumnFormatChanged(int)) );
 	connect( ui.leValuesPrefix, SIGNAL(returnPressed()), this, SLOT(valuesPrefixChanged()) );
 	connect( ui.leValuesSuffix, SIGNAL(returnPressed()), this, SLOT(valuesSuffixChanged()) );
 	connect( ui.kfrValuesFont, SIGNAL(fontSelected(QFont)), this, SLOT(valuesFontChanged(QFont)) );
 	connect( ui.kcbValuesColor, SIGNAL(changed(QColor)), this, SLOT(valuesColorChanged(QColor)) );
 
 	//Filling
 	connect(ui.chkFillingEnabled, &QCheckBox::stateChanged, this, &HistogramDock::fillingEnabledChanged);
 	connect( ui.cbFillingType, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingTypeChanged(int)) );
 	connect( ui.cbFillingColorStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingColorStyleChanged(int)) );
 	connect( ui.cbFillingImageStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingImageStyleChanged(int)) );
 	connect( ui.cbFillingBrushStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingBrushStyleChanged(int)) );
 	connect( ui.bFillingOpen, SIGNAL(clicked(bool)), this, SLOT(selectFile()));
 	connect( ui.leFillingFileName, SIGNAL(returnPressed()), this, SLOT(fileNameChanged()) );
 	connect( ui.leFillingFileName, SIGNAL(textChanged(QString)), this, SLOT(fileNameChanged()) );
 	connect( ui.kcbFillingFirstColor, SIGNAL(changed(QColor)), this, SLOT(fillingFirstColorChanged(QColor)) );
 	connect( ui.kcbFillingSecondColor, SIGNAL(changed(QColor)), this, SLOT(fillingSecondColorChanged(QColor)) );
 	connect( ui.sbFillingOpacity, SIGNAL(valueChanged(int)), this, SLOT(fillingOpacityChanged(int)) );
 
 	//Error bars
 	connect( ui.cbErrorType, SIGNAL(currentIndexChanged(int)), this, SLOT(errorTypeChanged(int)) );
 	connect( ui.cbErrorBarsType, SIGNAL(currentIndexChanged(int)), this, SLOT(errorBarsTypeChanged(int)) );
 	connect( ui.sbErrorBarsCapSize, SIGNAL(valueChanged(double)), this, SLOT(errorBarsCapSizeChanged(double)) );
 	connect( ui.cbErrorBarsStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(errorBarsStyleChanged(int)) );
 	connect( ui.kcbErrorBarsColor, SIGNAL(changed(QColor)), this, SLOT(errorBarsColorChanged(QColor)) );
 	connect( ui.sbErrorBarsWidth, SIGNAL(valueChanged(double)), this, SLOT(errorBarsWidthChanged(double)) );
 	connect( ui.sbErrorBarsOpacity, SIGNAL(valueChanged(int)), this, SLOT(errorBarsOpacityChanged(int)) );
 
 	//template handler
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Histogram);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Histogram);
 	ui.verticalLayout->addWidget(templateHandler);
 	templateHandler->show();
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 
 	retranslateUi();
 	init();
 
 	//TODO: activate the tab for error-bars again once the functionality is implemented
 	ui.tabWidget->removeTab(5);
 }
 
 HistogramDock::~HistogramDock() {
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 }
 
 void HistogramDock::init(){
 	//General
 	//bins option
 	ui.cbBinningMethod->addItem(i18n("By Number"));
 	ui.cbBinningMethod->addItem(i18n("By Width"));
 	ui.cbBinningMethod->addItem(i18n("Square-root"));
 	ui.cbBinningMethod->addItem(i18n("Rice"));
 	ui.cbBinningMethod->addItem(i18n("Sturges"));
 	ui.cbBinningMethod->addItem(i18n("Doane"));
 	ui.cbBinningMethod->addItem(i18n("Scott"));
 
 	//histogram type
 	ui.cbType->addItem(i18n("Ordinary Histogram"));
 	ui.cbType->addItem(i18n("Cumulative Histogram"));
 // 	ui.cbType->addItem(i18n("AvgShifted Histogram"));
 
 	//Orientation
 	ui.cbOrientation->addItem(i18n("Vertical"));
 	ui.cbOrientation->addItem(i18n("Horizontal"));
 
 	//Line
 	ui.cbLineType->addItem(i18n("None"));
 	ui.cbLineType->addItem(i18n("Bars"));
 	ui.cbLineType->addItem(i18n("Envelope"));
 	ui.cbLineType->addItem(i18n("Drop Lines"));
 
 	GuiTools::updatePenStyles(ui.cbLineStyle, Qt::black);
 
 	//Symbols
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, Qt::black);
 
 	QPainter pa;
 	//TODO size of the icon depending on the actuall height of the combobox?
 	int iconSize = 20;
 	QPixmap pm(iconSize, iconSize);
 	ui.cbSymbolStyle->setIconSize(QSize(iconSize, iconSize));
 	QTransform trafo;
 	trafo.scale(15, 15);
 
 	QPen pen(Qt::SolidPattern, 0);
 	const QColor& color = (palette().color(QPalette::Base).lightness() < 128) ? Qt::white : Qt::black;
 	pen.setColor(color);
 	pa.setPen( pen );
 
 	ui.cbSymbolStyle->addItem(i18n("None"));
 	for (int i = 1; i < 19; ++i) {	//TODO: use enum count
 		auto style = (Symbol::Style)i;
 		pm.fill(Qt::transparent);
 		pa.begin(&pm);
 		pa.setPen(pen);
 		pa.setRenderHint(QPainter::Antialiasing);
 		pa.translate(iconSize/2,iconSize/2);
 		pa.drawPath(trafo.map(Symbol::pathFromStyle(style)));
 		pa.end();
         ui.cbSymbolStyle->addItem(QIcon(pm), Symbol::nameFromStyle(style));
 	}
 
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, Qt::black);
 	m_initializing = false;
 
 	//Values
 	ui.cbValuesType->addItem(i18n("No Values"));
 	ui.cbValuesType->addItem("Bin Entries Number");
 	ui.cbValuesType->addItem(i18n("Custom Column"));
 
 	ui.cbValuesPosition->addItem(i18n("Above"));
 	ui.cbValuesPosition->addItem(i18n("Below"));
 	ui.cbValuesPosition->addItem(i18n("Left"));
 	ui.cbValuesPosition->addItem(i18n("Right"));
 
 	//Filling
 	ui.cbFillingType->clear();
 	ui.cbFillingType->addItem(i18n("Color"));
 	ui.cbFillingType->addItem(i18n("Image"));
 	ui.cbFillingType->addItem(i18n("Pattern"));
 
 	ui.cbFillingColorStyle->clear();
 	ui.cbFillingColorStyle->addItem(i18n("Single Color"));
 	ui.cbFillingColorStyle->addItem(i18n("Horizontal Linear Gradient"));
 	ui.cbFillingColorStyle->addItem(i18n("Vertical Linear Gradient"));
 	ui.cbFillingColorStyle->addItem(i18n("Diagonal Linear Gradient (Start From Top Left)"));
 	ui.cbFillingColorStyle->addItem(i18n("Diagonal Linear Gradient (Start From Bottom Left)"));
 	ui.cbFillingColorStyle->addItem(i18n("Radial Gradient"));
 
 	ui.cbFillingImageStyle->clear();
 	ui.cbFillingImageStyle->addItem(i18n("Scaled and Cropped"));
 	ui.cbFillingImageStyle->addItem(i18n("Scaled"));
 	ui.cbFillingImageStyle->addItem(i18n("Scaled, Keep Proportions"));
 	ui.cbFillingImageStyle->addItem(i18n("Centered"));
 	ui.cbFillingImageStyle->addItem(i18n("Tiled"));
 	ui.cbFillingImageStyle->addItem(i18n("Center Tiled"));
 	GuiTools::updateBrushStyles(ui.cbFillingBrushStyle, Qt::SolidPattern);
 
 	//Error-bars
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawLine(3,10,17,10);//vert. line
 	pa.drawLine(10,3,10,17);//hor. line
 	pa.end();
 	ui.cbErrorBarsType->addItem(i18n("Bars"));
 	ui.cbErrorBarsType->setItemIcon(0, pm);
 
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10); //vert. line
 	pa.drawLine(10,3,10,17); //hor. line
 	pa.drawLine(7,3,13,3); //upper cap
 	pa.drawLine(7,17,13,17); //bottom cap
 	pa.drawLine(3,7,3,13); //left cap
 	pa.drawLine(17,7,17,13); //right cap
 	pa.end();
 	ui.cbErrorBarsType->addItem(i18n("Bars with Ends"));
 	ui.cbErrorBarsType->setItemIcon(1, pm);
 
 	ui.cbErrorType->addItem(i18n("No Errors"));
 
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, Qt::black);
 }
 
 void HistogramDock::setModel() {
 	m_aspectTreeModel->enablePlottableColumnsOnly(true);
 	m_aspectTreeModel->enableShowPlotDesignation(true);
 
 	QList<const char*> list;
 	list << "Folder" << "Workbook" << "Datapicker" << "DatapickerCurve" << "Spreadsheet"
 		<< "FileDataSource" << "Column" << "Worksheet" << "CartesianPlot" << "XYFitCurve" << "CantorWorksheet";
 
 	cbDataColumn->setTopLevelClasses(list);
 	cbValuesColumn->setTopLevelClasses(list);
 
 	list.clear();
 	list << "Column";
 	m_aspectTreeModel->setSelectableAspects(list);
 
 	cbDataColumn->setModel(m_aspectTreeModel);
 	cbValuesColumn->setModel(m_aspectTreeModel);
 }
 
 void HistogramDock::setCurves(QList<Histogram*> list){
 	m_initializing = true;
 	m_curvesList = list;
 	m_curve = list.first();
 	Q_ASSERT(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	setModel();
 
 	//if there are more then one curve in the list, disable the content in the tab "general"
 	if (m_curvesList.size()==1){
 		ui.lName->setEnabled(true);
 		ui.leName->setEnabled(true);
 		ui.lComment->setEnabled(true);
 		ui.leComment->setEnabled(true);
 
 		ui.lXColumn->setEnabled(true);
 		cbDataColumn->setEnabled(true);
 
 		this->setModelIndexFromColumn(cbDataColumn, m_curve->dataColumn());
 		this->setModelIndexFromColumn(cbValuesColumn, m_curve->valuesColumn());
 
 		ui.leName->setText(m_curve->name());
 		ui.leComment->setText(m_curve->comment());
 	}else {
 		ui.lName->setEnabled(false);
 		ui.leName->setEnabled(false);
 		ui.lComment->setEnabled(false);
 		ui.leComment->setEnabled(false);
 
 		ui.lXColumn->setEnabled(false);
 		cbDataColumn->setEnabled(false);
 
 		cbDataColumn->setCurrentModelIndex(QModelIndex());
 		cbValuesColumn->setCurrentModelIndex(QModelIndex());
 
 		ui.leName->setText("");
 		ui.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	ui.cbType->setCurrentIndex(m_curve->type());
 	ui.cbOrientation->setCurrentIndex(m_curve->orientation());
 	ui.cbBinningMethod->setCurrentIndex(m_curve->binningMethod());
 	ui.sbBinCount->setValue(m_curve->binCount());
 	ui.leBinWidth->setText(QString::number(m_curve->binWidth()));
 	ui.chkAutoBinRanges->setChecked(m_curve->autoBinRanges());
 	ui.leBinRangesMin->setText( QString::number(m_curve->binRangesMin()) );
 	ui.leBinRangesMax->setText( QString::number(m_curve->binRangesMax()) );
 	ui.chkVisible->setChecked( m_curve->isVisible() );
 
 	KConfig config("", KConfig::SimpleConfig);
 	loadConfig(config);
 
 	//Slots
 	//General-tab
 	connect(m_curve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_curve, &Histogram::dataColumnChanged, this, &HistogramDock::curveDataColumnChanged);
 	connect(m_curve, &Histogram::typeChanged, this, &HistogramDock::curveTypeChanged);
 	connect(m_curve, &Histogram::orientationChanged, this, &HistogramDock::curveOrientationChanged);
 	connect(m_curve, &Histogram::binningMethodChanged, this, &HistogramDock::curveBinningMethodChanged);
 	connect(m_curve, &Histogram::binCountChanged, this, &HistogramDock::curveBinCountChanged);
 	connect(m_curve, &Histogram::binWidthChanged, this, &HistogramDock::curveBinWidthChanged);
 	connect(m_curve, &Histogram::autoBinRangesChanged, this, &HistogramDock::curveAutoBinRangesChanged);
 	connect(m_curve, &Histogram::binRangesMinChanged, this, &HistogramDock::curveBinRangesMinChanged);
 	connect(m_curve, &Histogram::binRangesMaxChanged, this, &HistogramDock::curveBinRangesMaxChanged);
 	connect(m_curve, SIGNAL(visibilityChanged(bool)), this, SLOT(curveVisibilityChanged(bool)));
 
 	//Line-tab
 	connect(m_curve, SIGNAL(linePenChanged(QPen)), this, SLOT(curveLinePenChanged(QPen)));
 	connect(m_curve, SIGNAL(lineOpacityChanged(qreal)), this, SLOT(curveLineOpacityChanged(qreal)));
 
 	//Symbol-Tab
 	connect(m_curve, SIGNAL(symbolsStyleChanged(Symbol::Style)), this, SLOT(curveSymbolsStyleChanged(Symbol::Style)));
 	connect(m_curve, SIGNAL(symbolsSizeChanged(qreal)), this, SLOT(curveSymbolsSizeChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsRotationAngleChanged(qreal)), this, SLOT(curveSymbolsRotationAngleChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsOpacityChanged(qreal)), this, SLOT(curveSymbolsOpacityChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsBrushChanged(QBrush)), this, SLOT(curveSymbolsBrushChanged(QBrush)));
 	connect(m_curve, SIGNAL(symbolsPenChanged(QPen)), this, SLOT(curveSymbolsPenChanged(QPen)));
 
 	//Values-Tab
 	connect(m_curve, SIGNAL(valuesTypeChanged(Histogram::ValuesType)), this, SLOT(curveValuesTypeChanged(Histogram::ValuesType)));
 	connect(m_curve, SIGNAL(valuesColumnChanged(const AbstractColumn*)), this, SLOT(curveValuesColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(valuesPositionChanged(Histogram::ValuesPosition)), this, SLOT(curveValuesPositionChanged(Histogram::ValuesPosition)));
 	connect(m_curve, SIGNAL(valuesDistanceChanged(qreal)), this, SLOT(curveValuesDistanceChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesOpacityChanged(qreal)), this, SLOT(curveValuesOpacityChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesRotationAngleChanged(qreal)), this, SLOT(curveValuesRotationAngleChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesPrefixChanged(QString)), this, SLOT(curveValuesPrefixChanged(QString)));
 	connect(m_curve, SIGNAL(valuesSuffixChanged(QString)), this, SLOT(curveValuesSuffixChanged(QString)));
 	connect(m_curve, SIGNAL(valuesFontChanged(QFont)), this, SLOT(curveValuesFontChanged(QFont)));
 	connect(m_curve, SIGNAL(valuesColorChanged(QColor)), this, SLOT(curveValuesColorChanged(QColor)));
 
 	//Filling-Tab
 	connect( m_curve, SIGNAL(fillingTypeChanged(PlotArea::BackgroundType)), this, SLOT(curveFillingTypeChanged(PlotArea::BackgroundType)) );
 	connect( m_curve, SIGNAL(fillingColorStyleChanged(PlotArea::BackgroundColorStyle)), this, SLOT(curveFillingColorStyleChanged(PlotArea::BackgroundColorStyle)) );
 	connect( m_curve, SIGNAL(fillingImageStyleChanged(PlotArea::BackgroundImageStyle)), this, SLOT(curveFillingImageStyleChanged(PlotArea::BackgroundImageStyle)) );
 	connect( m_curve, SIGNAL(fillingBrushStyleChanged(Qt::BrushStyle)), this, SLOT(curveFillingBrushStyleChanged(Qt::BrushStyle)) );
 	connect( m_curve, SIGNAL(fillingFirstColorChanged(QColor&)), this, SLOT(curveFillingFirstColorChanged(QColor&)) );
 	connect( m_curve, SIGNAL(fillingSecondColorChanged(QColor&)), this, SLOT(curveFillingSecondColorChanged(QColor&)) );
 	connect( m_curve, SIGNAL(fillingFileNameChanged(QString&)), this, SLOT(curveFillingFileNameChanged(QString&)) );
 	connect( m_curve, SIGNAL(fillingOpacityChanged(float)), this, SLOT(curveFillingOpacityChanged(float)) );
 
 	//"Error bars"-Tab
 	connect(m_curve, SIGNAL(errorTypeChanged(Histogram::ErrorType)), this, SLOT(curveErrorTypeChanged(Histogram::ErrorType)));
 	connect(m_curve, SIGNAL(errorBarsCapSizeChanged(qreal)), this, SLOT(curveErrorBarsCapSizeChanged(qreal)));
 	connect(m_curve, SIGNAL(errorBarsTypeChanged(XYCurve::ErrorBarsType)), this, SLOT(curveErrorBarsTypeChanged(XYCurve::ErrorBarsType)));
 	connect(m_curve, SIGNAL(errorBarsPenChanged(QPen)), this, SLOT(curveErrorBarsPenChanged(QPen)));
 	connect(m_curve, SIGNAL(errorBarsOpacityChanged(qreal)), this, SLOT(curveErrorBarsOpacityChanged(qreal)));
 
 	m_initializing=false;
 }
 
 void HistogramDock::setModelIndexFromColumn(TreeViewComboBox* cb, const AbstractColumn* column) {
 	if (column)
 		cb->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(column));
 	else
 		cb->setCurrentModelIndex(QModelIndex());
 }
 
 void HistogramDock::retranslateUi() {
 	//TODO:
 // 	ui.lName->setText(i18n("Name"));
 // 	ui.lComment->setText(i18n("Comment"));
 // 	ui.chkVisible->setText(i18n("Visible"));
 // 	ui.lXColumn->setText(i18n("x-data"));
 // 	ui.lYColumn->setText(i18n("y-data"));
 
 	//TODO updatePenStyles, updateBrushStyles for all comboboxes
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in HistogramDock *****
 //*************************************************************
 
 // "General"-tab
 void HistogramDock::nameChanged() {
 	if (m_initializing)
 	return;
 
 	m_curve->setName(ui.leName->text());
 }
 void HistogramDock::commentChanged() {
 	if (m_initializing)
 	return;
 
 	m_curve->setComment(ui.leComment->text());
 }
 
 void HistogramDock::visibilityChanged(bool state){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setVisible(state);
 }
 
 void HistogramDock::typeChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto histogramType = Histogram::HistogramType(index);
 	for (auto* curve : m_curvesList)
 		curve->setType(histogramType);
 }
 
 void HistogramDock::dataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column(nullptr);
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve : m_curvesList)
 		curve->setDataColumn(column);
 }
 
 void HistogramDock::orientationChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto orientation = Histogram::HistogramOrientation(index);
 	for (auto* curve : m_curvesList)
 		curve->setOrientation(orientation);
 }
 
 void HistogramDock::binningMethodChanged(int index) {
 	const auto binningMethod = Histogram::BinningMethod(index);
 	if (binningMethod == Histogram::ByNumber) {
 		ui.lBinCount->show();
 		ui.sbBinCount->show();
 		ui.lBinWidth->hide();
 		ui.leBinWidth->hide();
 	} else if (binningMethod == Histogram::ByWidth) {
 		ui.lBinCount->hide();
 		ui.sbBinCount->hide();
 		ui.lBinWidth->show();
 		ui.leBinWidth->show();
 	} else {
 		ui.lBinCount->hide();
 		ui.sbBinCount->hide();
 		ui.lBinWidth->hide();
 		ui.leBinWidth->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setBinningMethod(binningMethod);
 }
 
 void HistogramDock::binCountChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setBinCount(value);
 }
 
 void HistogramDock::binWidthChanged() {
 	if (m_initializing)
 		return;
 
 	float width = ui.leBinWidth->text().toDouble();
 	for (auto* curve : m_curvesList)
 		curve->setBinWidth(width);
 }
 
 void HistogramDock::autoBinRangesChanged(int state) {
 	bool checked = (state==Qt::Checked);
 	ui.leBinRangesMin->setEnabled(!checked);
 	ui.leBinRangesMax->setEnabled(!checked);
 
 	if (m_initializing)
 		return;
 
 	for (auto* hist : m_curvesList)
 		hist->setAutoBinRanges(checked);
 }
 
 void HistogramDock::binRangesMinChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const double min = value.toDouble();
 	for (auto* hist : m_curvesList)
 		hist->setBinRangesMin(min);
 }
 
 void HistogramDock::binRangesMaxChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const double max = value.toDouble();
 	for (auto* hist : m_curvesList)
 		hist->setBinRangesMax(max);
 }
 
 //Line tab
 void HistogramDock::lineTypeChanged(int index) {
 	auto lineType = Histogram::LineType(index);
 
 	if ( lineType == Histogram::NoLine) {
 		ui.cbLineStyle->setEnabled(false);
 		ui.kcbLineColor->setEnabled(false);
 		ui.sbLineWidth->setEnabled(false);
 		ui.sbLineOpacity->setEnabled(false);
 	} else {
 		ui.cbLineStyle->setEnabled(true);
 		ui.kcbLineColor->setEnabled(true);
 		ui.sbLineWidth->setEnabled(true);
 		ui.sbLineOpacity->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setLineType(lineType);
 }
 
 void HistogramDock::lineStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto penStyle = Qt::PenStyle(index);
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setStyle(penStyle);
 		curve->setLinePen(pen);
 	}
 }
 
 void HistogramDock::lineColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setColor(color);
 		curve->setLinePen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, color);
 	m_initializing = false;
 }
 
 void HistogramDock::lineWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setLinePen(pen);
 	}
 }
 
 void HistogramDock::lineOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setLineOpacity(opacity);
 }
 
 //"Symbol"-tab
 void HistogramDock::symbolsStyleChanged(int index) {
 	const auto style = Symbol::Style(index);
 
 	if (style == Symbol::NoSymbols) {
 		ui.sbSymbolSize->setEnabled(false);
 		ui.sbSymbolRotation->setEnabled(false);
 		ui.sbSymbolOpacity->setEnabled(false);
 
 		ui.kcbSymbolFillingColor->setEnabled(false);
 		ui.cbSymbolFillingStyle->setEnabled(false);
 
 		ui.cbSymbolBorderStyle->setEnabled(false);
 		ui.kcbSymbolBorderColor->setEnabled(false);
 		ui.sbSymbolBorderWidth->setEnabled(false);
 	} else {
 		ui.sbSymbolSize->setEnabled(true);
 		ui.sbSymbolRotation->setEnabled(true);
 		ui.sbSymbolOpacity->setEnabled(true);
 
 		//enable/disable the symbol filling options in the GUI depending on the currently selected symbol.
 		if (style != Symbol::Line && style != Symbol::Cross) {
 			ui.cbSymbolFillingStyle->setEnabled(true);
 			bool noBrush = (Qt::BrushStyle(ui.cbSymbolFillingStyle->currentIndex()) == Qt::NoBrush);
 			ui.kcbSymbolFillingColor->setEnabled(!noBrush);
 		} else {
 			ui.kcbSymbolFillingColor->setEnabled(false);
 			ui.cbSymbolFillingStyle->setEnabled(false);
 		}
 
 		ui.cbSymbolBorderStyle->setEnabled(true);
 		bool noLine = (Qt::PenStyle(ui.cbSymbolBorderStyle->currentIndex()) == Qt::NoPen);
 		ui.kcbSymbolBorderColor->setEnabled(!noLine);
 		ui.sbSymbolBorderWidth->setEnabled(!noLine);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsStyle(style);
 }
 
 void HistogramDock::symbolsSizeChanged(double value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsSize( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void HistogramDock::symbolsRotationChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsRotationAngle(value);
 }
 
 void HistogramDock::symbolsOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsOpacity(opacity);
 }
 
 void HistogramDock::symbolsFillingStyleChanged(int index) {
 	auto brushStyle = Qt::BrushStyle(index);
 	ui.kcbSymbolFillingColor->setEnabled(!(brushStyle == Qt::NoBrush));
 
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	for (auto* curve : m_curvesList) {
 		brush = curve->symbolsBrush();
 		brush.setStyle(brushStyle);
 		curve->setSymbolsBrush(brush);
 	}
 }
 
 void HistogramDock::symbolsFillingColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	for (auto* curve : m_curvesList) {
 		brush = curve->symbolsBrush();
 		brush.setColor(color);
 		curve->setSymbolsBrush(brush);
 	}
 
 	m_initializing = true;
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, color );
 	m_initializing = false;
 }
 
 void HistogramDock::symbolsBorderStyleChanged(int index) {
 	auto penStyle = Qt::PenStyle(index);
 
 	if ( penStyle == Qt::NoPen ) {
 		ui.kcbSymbolBorderColor->setEnabled(false);
 		ui.sbSymbolBorderWidth->setEnabled(false);
 	} else {
 		ui.kcbSymbolBorderColor->setEnabled(true);
 		ui.sbSymbolBorderWidth->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->symbolsPen();
 		pen.setStyle(penStyle);
 		curve->setSymbolsPen(pen);
 	}
 }
 
 void HistogramDock::symbolsBorderColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen=curve->symbolsPen();
 		pen.setColor(color);
 		curve->setSymbolsPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, color);
 	m_initializing = false;
 }
 
 void HistogramDock::symbolsBorderWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen=curve->symbolsPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setSymbolsPen(pen);
 	}
 }
 
 //Values tab
 /*!
   called when the type of the values (none, x, y, (x,y) etc.) was changed.
 */
 void HistogramDock::valuesTypeChanged(int index) {
 	auto valuesType = Histogram::ValuesType(index);
 
 	if (valuesType == Histogram::NoValues){
 		//no values are to paint -> deactivate all the pertinent widgets
 		ui.cbValuesPosition->setEnabled(false);
 		ui.lValuesColumn->hide();
 		cbValuesColumn->hide();
 		ui.sbValuesDistance->setEnabled(false);
 		ui.sbValuesRotation->setEnabled(false);
 		ui.sbValuesOpacity->setEnabled(false);
 		ui.cbValuesFormat->setEnabled(false);
 		ui.cbValuesFormat->setEnabled(false);
 		ui.sbValuesPrecision->setEnabled(false);
 		ui.leValuesPrefix->setEnabled(false);
 		ui.leValuesSuffix->setEnabled(false);
 		ui.kfrValuesFont->setEnabled(false);
 		ui.kcbValuesColor->setEnabled(false);
 	} else {
 		ui.cbValuesPosition->setEnabled(true);
 		ui.sbValuesDistance->setEnabled(true);
 		ui.sbValuesRotation->setEnabled(true);
 		ui.sbValuesOpacity->setEnabled(true);
 		ui.cbValuesFormat->setEnabled(true);
 		ui.sbValuesPrecision->setEnabled(true);
 		ui.leValuesPrefix->setEnabled(true);
 		ui.leValuesSuffix->setEnabled(true);
 		ui.kfrValuesFont->setEnabled(true);
 		ui.kcbValuesColor->setEnabled(true);
 
 		const Column* column;
 		if (valuesType == Histogram::ValuesCustomColumn) {
 			ui.lValuesColumn->show();
 			cbValuesColumn->show();
 
 			column= static_cast<Column*>(cbValuesColumn->currentModelIndex().internalPointer());
 		} else {
 			ui.lValuesColumn->hide();
 			cbValuesColumn->hide();
 			column = static_cast<const Column*>(m_curve->dataColumn());
 		}
 		this->showValuesColumnFormat(column);
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesType(valuesType);
 }
 
 //TODO: very similar to ColumnDock
 void HistogramDock::showValuesColumnFormat(const Column* column){
   if (!column){
 	// no valid column is available
 	// -> hide all the format properties widgets (equivalent to showing the properties of the column mode "Text")
 	this->updateValuesFormatWidgets(AbstractColumn::Text);
   }else{
 	AbstractColumn::ColumnMode columnMode = column->columnMode();
 
 	//update the format widgets for the new column mode
 	this->updateValuesFormatWidgets(columnMode);
 
 	 //show the actual formatting properties
 	switch(columnMode) {
 		case AbstractColumn::Numeric:{
-		  auto filter = static_cast<Double2StringFilter*>(column->outputFilter());
+		  auto* filter = static_cast<Double2StringFilter*>(column->outputFilter());
 		  ui.cbValuesFormat->setCurrentIndex(ui.cbValuesFormat->findData(filter->numericFormat()));
 		  ui.sbValuesPrecision->setValue(filter->numDigits());
 		  break;
 		}
 		case AbstractColumn::Text:
 		case AbstractColumn::Integer:
 			break;
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 		case AbstractColumn::DateTime: {
-				auto filter = static_cast<DateTime2StringFilter*>(column->outputFilter());
+				auto* filter = static_cast<DateTime2StringFilter*>(column->outputFilter());
 				ui.cbValuesFormat->setCurrentIndex(ui.cbValuesFormat->findData(filter->format()));
 				break;
 			}
 	}
   }
 }
 
 //TODO: very similar to ColumnDock
 void HistogramDock::updateValuesFormatWidgets(const AbstractColumn::ColumnMode columnMode) {
 	ui.cbValuesFormat->clear();
 
 	switch (columnMode) {
 	case AbstractColumn::Numeric:
 		ui.cbValuesFormat->addItem(i18n("Decimal"), QVariant('f'));
 		ui.cbValuesFormat->addItem(i18n("Scientific (e)"), QVariant('e'));
 		ui.cbValuesFormat->addItem(i18n("Scientific (E)"), QVariant('E'));
 		ui.cbValuesFormat->addItem(i18n("Automatic (e)"), QVariant('g'));
 		ui.cbValuesFormat->addItem(i18n("Automatic (E)"), QVariant('G'));
 		break;
 	case AbstractColumn::Integer:
 		break;
 	case AbstractColumn::Text:
 		ui.cbValuesFormat->addItem(i18n("Text"), QVariant());
 		break;
 	case AbstractColumn::Month:
 		ui.cbValuesFormat->addItem(i18n("Number without Leading Zero"), QVariant("M"));
 		ui.cbValuesFormat->addItem(i18n("Number with Leading Zero"), QVariant("MM"));
 		ui.cbValuesFormat->addItem(i18n("Abbreviated Month Name"), QVariant("MMM"));
 		ui.cbValuesFormat->addItem(i18n("Full Month Name"), QVariant("MMMM"));
 		break;
 	case AbstractColumn::Day:
 		ui.cbValuesFormat->addItem(i18n("Number without Leading Zero"), QVariant("d"));
 		ui.cbValuesFormat->addItem(i18n("Number with Leading Zero"), QVariant("dd"));
 		ui.cbValuesFormat->addItem(i18n("Abbreviated Day Name"), QVariant("ddd"));
 		ui.cbValuesFormat->addItem(i18n("Full Day Name"), QVariant("dddd"));
 		break;
 	case AbstractColumn::DateTime:
-		for (const auto& s: AbstractColumn::dateFormats())
+		for (const auto& s : AbstractColumn::dateFormats())
 			ui.cbValuesFormat->addItem(s, QVariant(s));
 
-		for (const auto& s: AbstractColumn::timeFormats())
+		for (const auto& s : AbstractColumn::timeFormats())
 			ui.cbValuesFormat->addItem(s, QVariant(s));
 
-		for (const auto& s1: AbstractColumn::dateFormats())
-			for (const auto& s2: AbstractColumn::timeFormats())
+		for (const auto& s1 : AbstractColumn::dateFormats())
+			for (const auto& s2 : AbstractColumn::timeFormats())
 				ui.cbValuesFormat->addItem(s1 + ' ' + s2, QVariant(s1 + ' ' + s2));
 		break;
 	}
 
 	ui.cbValuesFormat->setCurrentIndex(0);
 
 	if (columnMode == AbstractColumn::Numeric) {
 		ui.lValuesPrecision->show();
 		ui.sbValuesPrecision->show();
 	} else {
 		ui.lValuesPrecision->hide();
 		ui.sbValuesPrecision->hide();
 	}
 
 	if (columnMode == AbstractColumn::Text) {
 		ui.lValuesFormatTop->hide();
 		ui.lValuesFormat->hide();
 		ui.cbValuesFormat->hide();
 	} else {
 		ui.lValuesFormatTop->show();
 		ui.lValuesFormat->show();
 		ui.cbValuesFormat->show();
 		ui.cbValuesFormat->setCurrentIndex(0);
 	}
 
 	if (columnMode == AbstractColumn::DateTime) {
 		ui.cbValuesFormat->setEditable(true);
 	} else {
 		ui.cbValuesFormat->setEditable(false);
 	}
 }
 
 /*!
   called when the custom column for the values was changed.
 */
 void HistogramDock::valuesColumnChanged(const QModelIndex& index){
 	if (m_initializing)
 		return;
 
-	auto column = static_cast<Column*>(index.internalPointer());
+	auto* column = static_cast<Column*>(index.internalPointer());
 	this->showValuesColumnFormat(column);
 
-	for (auto* curve: m_curvesList) {
+	for (auto* curve : m_curvesList) {
 	//TODO save also the format of the currently selected column for the values (precision etc.)
 		curve->setValuesColumn(column);
 	}
 }
 
 void HistogramDock::valuesPositionChanged(int index){
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesPosition(Histogram::ValuesPosition(index));
 }
 
 void HistogramDock::valuesDistanceChanged(double  value){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesDistance( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void HistogramDock::valuesRotationChanged(int value){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesRotationAngle(value);
 }
 
 void HistogramDock::valuesOpacityChanged(int value){
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesOpacity(opacity);
 }
 
 void HistogramDock::valuesPrefixChanged(){
 	if (m_initializing)
 		return;
 
 	QString prefix = ui.leValuesPrefix->text();
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesPrefix(prefix);
 }
 
 void HistogramDock::valuesSuffixChanged(){
 	if (m_initializing)
 		return;
 
 	QString suffix = ui.leValuesSuffix->text();
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesSuffix(suffix);
 }
 
 void HistogramDock::valuesFontChanged(const QFont& font){
 	if (m_initializing)
 		return;
 
 	QFont valuesFont = font;
 	valuesFont.setPixelSize( Worksheet::convertToSceneUnits(font.pointSizeF(), Worksheet::Point) );
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesFont(valuesFont);
 }
 
 void HistogramDock::valuesColorChanged(const QColor& color){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setValuesColor(color);
 }
 
 //Filling-tab
 void HistogramDock::fillingEnabledChanged(int state) {
 	ui.cbFillingType->setEnabled(state);
 	ui.cbFillingColorStyle->setEnabled(state);
 	ui.cbFillingBrushStyle->setEnabled(state);
 	ui.cbFillingImageStyle->setEnabled(state);
 	ui.kcbFillingFirstColor->setEnabled(state);
 	ui.kcbFillingSecondColor->setEnabled(state);
 	ui.leFillingFileName->setEnabled(state);
 	ui.bFillingOpen->setEnabled(state);
 	ui.sbFillingOpacity->setEnabled(state);
 
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingEnabled(state);
 }
 
 void HistogramDock::fillingTypeChanged(int index){
 	auto type = (PlotArea::BackgroundType)index;
 
 	if (type == PlotArea::Color){
 		ui.lFillingColorStyle->show();
 		ui.cbFillingColorStyle->show();
 		ui.lFillingImageStyle->hide();
 		ui.cbFillingImageStyle->hide();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 
 		ui.lFillingFileName->hide();
 		ui.leFillingFileName->hide();
 		ui.bFillingOpen->hide();
 
 		ui.lFillingFirstColor->show();
 		ui.kcbFillingFirstColor->show();
 
 		auto style = (PlotArea::BackgroundColorStyle) ui.cbFillingColorStyle->currentIndex();
 		if (style == PlotArea::SingleColor){
 			ui.lFillingFirstColor->setText(i18n("Color:"));
 			ui.lFillingSecondColor->hide();
 			ui.kcbFillingSecondColor->hide();
 		}else{
 			ui.lFillingFirstColor->setText(i18n("First color:"));
 			ui.lFillingSecondColor->show();
 			ui.kcbFillingSecondColor->show();
 		}
 	}else if(type == PlotArea::Image){
 		ui.lFillingColorStyle->hide();
 		ui.cbFillingColorStyle->hide();
 		ui.lFillingImageStyle->show();
 		ui.cbFillingImageStyle->show();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 		ui.lFillingFileName->show();
 		ui.leFillingFileName->show();
 		ui.bFillingOpen->show();
 
 		ui.lFillingFirstColor->hide();
 		ui.kcbFillingFirstColor->hide();
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	}else if(type == PlotArea::Pattern) {
 		ui.lFillingFirstColor->setText(i18n("Color:"));
 		ui.lFillingColorStyle->hide();
 		ui.cbFillingColorStyle->hide();
 		ui.lFillingImageStyle->hide();
 		ui.cbFillingImageStyle->hide();
 		ui.lFillingBrushStyle->show();
 		ui.cbFillingBrushStyle->show();
 		ui.lFillingFileName->hide();
 		ui.leFillingFileName->hide();
 		ui.bFillingOpen->hide();
 
 		ui.lFillingFirstColor->show();
 		ui.kcbFillingFirstColor->show();
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingType(type);
 }
 
 void HistogramDock::fillingColorStyleChanged(int index){
 	auto style = (PlotArea::BackgroundColorStyle)index;
 
 	if (style == PlotArea::SingleColor){
 		ui.lFillingFirstColor->setText(i18n("Color:"));
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	} else {
 		ui.lFillingFirstColor->setText(i18n("First color:"));
 		ui.lFillingSecondColor->show();
 		ui.kcbFillingSecondColor->show();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 	}
 
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingColorStyle(style);
 }
 
 void HistogramDock::fillingImageStyleChanged(int index){
 	if (m_initializing)
 		return;
 
 	auto style = (PlotArea::BackgroundImageStyle)index;
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingImageStyle(style);
 }
 
 void HistogramDock::fillingBrushStyleChanged(int index){
 	if (m_initializing)
 		return;
 
 	auto style = (Qt::BrushStyle)index;
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingBrushStyle(style);
 }
 
 void HistogramDock::fillingFirstColorChanged(const QColor& c){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingFirstColor(c);
 }
 
 void HistogramDock::fillingSecondColorChanged(const QColor& c){
 	if (m_initializing)
 		return;
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingSecondColor(c);
 }
 
 //"Error bars"-Tab
 void HistogramDock::errorTypeChanged(int index) const {
 	bool b = (index != 0);
 	ui.lErrorData->setVisible(b);
 	ui.lErrorFormat->setVisible(b);
 	ui.lErrorBarsType->setVisible(b);
 	ui.cbErrorBarsType->setVisible(b);
 	ui.lErrorBarsStyle->setVisible(b);
 	ui.cbErrorBarsStyle->setVisible(b);
 	ui.lErrorBarsColor->setVisible(b);
 	ui.kcbErrorBarsColor->setVisible(b);
 	ui.lErrorBarsWidth->setVisible(b);
 	ui.sbErrorBarsWidth->setVisible(b);
 	ui.lErrorBarsOpacity->setVisible(b);
 	ui.sbErrorBarsOpacity->setVisible(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setErrorType(Histogram::ErrorType(index));
 }
 
 void HistogramDock::errorBarsTypeChanged(int index) const {
 	auto type = XYCurve::ErrorBarsType(index);
 	bool b = (type == XYCurve::ErrorBarsWithEnds);
 	ui.lErrorBarsCapSize->setVisible(b);
 	ui.sbErrorBarsCapSize->setVisible(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsType(type);
 }
 
 void HistogramDock::errorBarsCapSizeChanged(double value) const {
 	if (m_initializing)
 		return;
 
 	float size = Worksheet::convertToSceneUnits(value, Worksheet::Point);
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsCapSize(size);
 }
 
 void HistogramDock::errorBarsStyleChanged(int index) const {
 	if (m_initializing)
 		return;
 
 	auto penStyle = Qt::PenStyle(index);
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setStyle(penStyle);
 		curve->setErrorBarsPen(pen);
 	}
 }
 
 void HistogramDock::errorBarsColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setColor(color);
 		curve->setErrorBarsPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, color);
 	m_initializing = false;
 }
 
 void HistogramDock::errorBarsWidthChanged(double value) const {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setErrorBarsPen(pen);
 	}
 }
 
 void HistogramDock::errorBarsOpacityChanged(int value) const {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsOpacity(opacity);
 }
 
 /*!
 	opens a file dialog and lets the user select the image file.
 */
 void HistogramDock::selectFile() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "HistogramDock");
 	QString dir = conf.readEntry("LastImageDir", "");
 
 	QString formats;
 	for (const QByteArray& format : QImageReader::supportedImageFormats()) {
 		QString f = "*." + QString(format.constData());
 		formats.isEmpty() ? formats+=f : formats+=' '+f;
 	}
 
 	QString path = QFileDialog::getOpenFileName(this, i18n("Select the image file"), dir, i18n("Images (%1)", formats));
 	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("LastImageDir", newDir);
 	}
 
 	ui.leFillingFileName->setText( path );
 
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingFileName(path);
 }
 
 void HistogramDock::fileNameChanged(){
 	if (m_initializing)
 		return;
 
 	QString fileName = ui.leFillingFileName->text();
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingFileName(fileName);
 }
 
 void HistogramDock::fillingOpacityChanged(int value){
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
-	for (auto* curve: m_curvesList)
+	for (auto* curve : m_curvesList)
 		curve->setFillingOpacity(opacity);
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in Histogram *******
 //*************************************************************
 
 //General-Tab
 void HistogramDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.leComment->text())
 		ui.leComment->setText(aspect->comment());
 
 	m_initializing = false;
 }
 
 void HistogramDock::curveDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromColumn(cbDataColumn, column);
 	m_initializing = false;
 }
 
 void HistogramDock::curveTypeChanged(Histogram::HistogramType type) {
 	m_initializing = true;
 	ui.cbType->setCurrentIndex((int)type);
 	m_initializing = false;
 }
 
 void HistogramDock::curveOrientationChanged(Histogram::HistogramOrientation orientation) {
 	m_initializing = true;
 	ui.cbOrientation->setCurrentIndex((int)orientation);
 	m_initializing = false;
 }
 
 void HistogramDock::curveBinningMethodChanged(Histogram::BinningMethod method) {
 	m_initializing = true;
 	ui.cbBinningMethod->setCurrentIndex((int)method);
 	m_initializing = false;
 }
 
 void HistogramDock::curveBinCountChanged(int count) {
 	m_initializing = true;
 	ui.sbBinCount->setValue(count);
 	m_initializing = false;
 }
 
 void HistogramDock::curveBinWidthChanged(float width) {
 	m_initializing = true;
 	ui.leBinWidth->setText(QString::number(width));
 	m_initializing = false;
 }
 
 void HistogramDock::curveAutoBinRangesChanged(bool value) {
 	m_initializing = true;
 	ui.chkAutoBinRanges->setChecked(value);
 	m_initializing = false;
 }
 
 void HistogramDock::curveBinRangesMinChanged(double value) {
 	m_initializing = true;
 	ui.leBinRangesMin->setText( QString::number(value) );
 	m_initializing = false;
 }
 
 void HistogramDock::curveBinRangesMaxChanged(double value) {
 	m_initializing = true;
 	ui.leBinRangesMax->setText( QString::number(value) );
 	m_initializing = false;
 }
 
 //Line-Tab
 void HistogramDock::curveLineTypeChanged(Histogram::LineType type) {
 	m_initializing = true;
 	ui.cbLineType->setCurrentIndex((int)type);
 	m_initializing = false;
 }
 void HistogramDock::curveLinePenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbLineStyle->setCurrentIndex( (int)pen.style());
 	ui.kcbLineColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbLineStyle, pen.color());
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits( pen.widthF(), Worksheet::Point) );
 	m_initializing = false;
 }
 void HistogramDock::curveLineOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbLineOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //Symbol-Tab
 void HistogramDock::curveSymbolsStyleChanged(Symbol::Style style) {
 	m_initializing = true;
 	ui.cbSymbolStyle->setCurrentIndex((int)style);
 	m_initializing = false;
 }
 void HistogramDock::curveSymbolsSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 void HistogramDock::curveSymbolsRotationAngleChanged(qreal angle) {
 	m_initializing = true;
 	ui.sbSymbolRotation->setValue(angle);
 	m_initializing = false;
 }
 void HistogramDock::curveSymbolsOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbSymbolOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void HistogramDock::curveSymbolsBrushChanged(const QBrush& brush) {
 	m_initializing = true;
 	ui.cbSymbolFillingStyle->setCurrentIndex((int) brush.style());
 	ui.kcbSymbolFillingColor->setColor(brush.color());
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, brush.color());
 	m_initializing = false;
 }
 void HistogramDock::curveSymbolsPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbSymbolBorderStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbSymbolBorderColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, pen.color());
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(), Worksheet::Point));
 	m_initializing = false;
 }
 
 //Values-Tab
 void HistogramDock::curveValuesTypeChanged(Histogram::ValuesType type) {
 	m_initializing = true;
 	ui.cbValuesType->setCurrentIndex((int) type);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromColumn(cbValuesColumn, column);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesPositionChanged(Histogram::ValuesPosition position) {
 	m_initializing = true;
   	ui.cbValuesPosition->setCurrentIndex((int) position);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesDistanceChanged(qreal distance) {
 	m_initializing = true;
   	ui.sbValuesDistance->setValue( Worksheet::convertFromSceneUnits(distance, Worksheet::Point) );
 	m_initializing = false;
 }
 void HistogramDock::curveValuesRotationAngleChanged(qreal angle) {
 	m_initializing = true;
 	ui.sbValuesRotation->setValue(angle);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbValuesOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void HistogramDock::curveValuesPrefixChanged(const QString& prefix) {
 	m_initializing = true;
   	ui.leValuesPrefix->setText(prefix);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesSuffixChanged(const QString& suffix) {
 	m_initializing = true;
   	ui.leValuesSuffix->setText(suffix);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesFontChanged(QFont font) {
 	m_initializing = true;
 	font.setPointSizeF( round(Worksheet::convertFromSceneUnits(font.pixelSize(), Worksheet::Point)) );
   	ui.kfrValuesFont->setFont(font);
 	m_initializing = false;
 }
 void HistogramDock::curveValuesColorChanged(QColor color) {
 	m_initializing = true;
   	ui.kcbValuesColor->setColor(color);
 	m_initializing = false;
 }
 
 void HistogramDock::curveVisibilityChanged(bool on) {
 	m_initializing = true;
 	ui.chkVisible->setChecked(on);
 	m_initializing = false;
 }
 
 //Filling
 void HistogramDock::curveFillingEnabledChanged(bool status) {
 	m_initializing = true;
 	ui.chkFillingEnabled->setChecked(status);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingTypeChanged(PlotArea::BackgroundType type){
 	m_initializing = true;
 	ui.cbFillingType->setCurrentIndex(type);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingColorStyleChanged(PlotArea::BackgroundColorStyle style){
 	m_initializing = true;
 	ui.cbFillingColorStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingImageStyleChanged(PlotArea::BackgroundImageStyle style){
 	m_initializing = true;
 	ui.cbFillingImageStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingBrushStyleChanged(Qt::BrushStyle style){
 	m_initializing = true;
 	ui.cbFillingBrushStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingFirstColorChanged(QColor& color){
 	m_initializing = true;
 	ui.kcbFillingFirstColor->setColor(color);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingSecondColorChanged(QColor& color){
 	m_initializing = true;
 	ui.kcbFillingSecondColor->setColor(color);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingFileNameChanged(QString& filename){
 	m_initializing = true;
 	ui.leFillingFileName->setText(filename);
 	m_initializing = false;
 }
 void HistogramDock::curveFillingOpacityChanged(float opacity){
 	m_initializing = true;
 	ui.sbFillingOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 
 //"Error bars"-Tab
 void HistogramDock::curveErrorTypeChanged(Histogram::ErrorType type) {
 	m_initializing = true;
 	ui.cbErrorType->setCurrentIndex((int)type);
 	m_initializing = false;
 }
 void HistogramDock::curveErrorBarsCapSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbErrorBarsCapSize->setValue( Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 void HistogramDock::curveErrorBarsTypeChanged(XYCurve::ErrorBarsType type) {
 	m_initializing = true;
 	ui.cbErrorBarsType->setCurrentIndex((int)type);
 	m_initializing = false;
 }
 void HistogramDock::curveErrorBarsPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbErrorBarsStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbErrorBarsColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, pen.color());
 	ui.sbErrorBarsWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point) );
 	m_initializing = false;
 }
 void HistogramDock::curveErrorBarsOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbErrorBarsOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //*************************************************************
 //************************* Settings **************************
 //*************************************************************
 void HistogramDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group(QLatin1String("Histogram"));
 
   	//General
 	//we don't load/save the settings in the general-tab, since they are not style related.
 	//It doesn't make sense to load/save them in the template.
 	//This data is read in HistogramDock::setCurves().
 
 	//Line
 	ui.cbLineType->setCurrentIndex( group.readEntry("LineType", (int) m_curve->lineType()) );
 	ui.cbLineStyle->setCurrentIndex( group.readEntry("LineStyle", (int) m_curve->linePen().style()) );
 	ui.kcbLineColor->setColor( group.readEntry("LineColor", m_curve->linePen().color()) );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("LineWidth", m_curve->linePen().widthF()), Worksheet::Point) );
 	ui.sbLineOpacity->setValue( round(group.readEntry("LineOpacity", m_curve->lineOpacity())*100.0) );
 
 	//Symbols
 	ui.cbSymbolStyle->setCurrentIndex( group.readEntry("SymbolStyle", (int)m_curve->symbolsStyle()) );
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolSize", m_curve->symbolsSize()), Worksheet::Point) );
 	ui.sbSymbolRotation->setValue( group.readEntry("SymbolRotation", m_curve->symbolsRotationAngle()) );
 	ui.sbSymbolOpacity->setValue( round(group.readEntry("SymbolOpacity", m_curve->symbolsOpacity())*100.0) );
 	ui.cbSymbolFillingStyle->setCurrentIndex( group.readEntry("SymbolFillingStyle", (int) m_curve->symbolsBrush().style()) );
 	ui.kcbSymbolFillingColor->setColor(  group.readEntry("SymbolFillingColor", m_curve->symbolsBrush().color()) );
 	ui.cbSymbolBorderStyle->setCurrentIndex( group.readEntry("SymbolBorderStyle", (int) m_curve->symbolsPen().style()) );
 	ui.kcbSymbolBorderColor->setColor( group.readEntry("SymbolBorderColor", m_curve->symbolsPen().color()) );
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolBorderWidth",m_curve->symbolsPen().widthF()), Worksheet::Point) );
 
   	//Values
   	ui.cbValuesType->setCurrentIndex( group.readEntry("ValuesType", (int) m_curve->valuesType()) );
   	ui.cbValuesPosition->setCurrentIndex( group.readEntry("ValuesPosition", (int) m_curve->valuesPosition()) );
   	ui.sbValuesDistance->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ValuesDistance", m_curve->valuesDistance()), Worksheet::Point) );
 	ui.sbValuesRotation->setValue( group.readEntry("ValuesRotation", m_curve->valuesRotationAngle()) );
 	ui.sbValuesOpacity->setValue( round(group.readEntry("ValuesOpacity",m_curve->valuesOpacity())*100.0) );
   	ui.leValuesPrefix->setText( group.readEntry("ValuesPrefix", m_curve->valuesPrefix()) );
   	ui.leValuesSuffix->setText( group.readEntry("ValuesSuffix", m_curve->valuesSuffix()) );
 	QFont valuesFont = m_curve->valuesFont();
 	valuesFont.setPointSizeF( round(Worksheet::convertFromSceneUnits(valuesFont.pixelSize(), Worksheet::Point)) );
   	ui.kfrValuesFont->setFont( group.readEntry("ValuesFont", valuesFont) );
   	ui.kcbValuesColor->setColor( group.readEntry("ValuesColor", m_curve->valuesColor()) );
 
 	//Filling
 	ui.chkFillingEnabled->setChecked( group.readEntry("FillingEnabled", m_curve->fillingEnabled()) );
 	ui.cbFillingType->setCurrentIndex( group.readEntry("FillingType", (int) m_curve->fillingType()) );
 	ui.cbFillingColorStyle->setCurrentIndex( group.readEntry("FillingColorStyle", (int) m_curve->fillingColorStyle()) );
 	ui.cbFillingImageStyle->setCurrentIndex( group.readEntry("FillingImageStyle", (int) m_curve->fillingImageStyle()) );
 	ui.cbFillingBrushStyle->setCurrentIndex( group.readEntry("FillingBrushStyle", (int) m_curve->fillingBrushStyle()) );
 	ui.leFillingFileName->setText( group.readEntry("FillingFileName", m_curve->fillingFileName()) );
 	ui.kcbFillingFirstColor->setColor( group.readEntry("FillingFirstColor", m_curve->fillingFirstColor()) );
 	ui.kcbFillingSecondColor->setColor( group.readEntry("FillingSecondColor", m_curve->fillingSecondColor()) );
 	ui.sbFillingOpacity->setValue( round(group.readEntry("FillingOpacity", m_curve->fillingOpacity())*100.0) );
 
 	//Error bars
 	ui.cbErrorType->setCurrentIndex( group.readEntry("ErrorType", (int) m_curve->errorType()) );
 	ui.cbErrorBarsType->setCurrentIndex( group.readEntry("ErrorBarsType", (int) m_curve->errorBarsType()) );
 	ui.sbErrorBarsCapSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ErrorBarsCapSize", m_curve->errorBarsCapSize()), Worksheet::Point) );
 	ui.cbErrorBarsStyle->setCurrentIndex( group.readEntry("ErrorBarsStyle", (int) m_curve->errorBarsPen().style()) );
 	ui.kcbErrorBarsColor->setColor( group.readEntry("ErrorBarsColor", m_curve->errorBarsPen().color()) );
 	ui.sbErrorBarsWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ErrorBarsWidth", m_curve->errorBarsPen().widthF()),Worksheet::Point) );
 	ui.sbErrorBarsOpacity->setValue( round(group.readEntry("ErrorBarsOpacity", m_curve->errorBarsOpacity())*100.0) );
 }
 
 void HistogramDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index!=-1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	int size = m_curvesList.size();
 	if (size>1)
 		m_curve->beginMacro(i18n("%1 xy-curves: template \"%2\" loaded", size, name));
 	else
 		m_curve->beginMacro(i18n("%1: template \"%2\" loaded", m_curve->name(), name));
 
 	this->loadConfig(config);
 
 	m_curve->endMacro();
 }
 
 void HistogramDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "Histogram" );
 
 	//Line
 	group.writeEntry("LineType", ui.cbLineType->currentIndex());
 	group.writeEntry("LineStyle", ui.cbLineStyle->currentIndex());
 	group.writeEntry("LineColor", ui.kcbLineColor->color());
 	group.writeEntry("LineWidth", Worksheet::convertToSceneUnits(ui.sbLineWidth->value(),Worksheet::Point) );
 	group.writeEntry("LineOpacity", ui.sbLineOpacity->value()/100 );
 
 	//Values
 	group.writeEntry("ValuesType", ui.cbValuesType->currentIndex());
 	group.writeEntry("ValuesPosition", ui.cbValuesPosition->currentIndex());
 	group.writeEntry("ValuesDistance", Worksheet::convertToSceneUnits(ui.sbValuesDistance->value(),Worksheet::Point));
 	group.writeEntry("ValuesRotation", ui.sbValuesRotation->value());
 	group.writeEntry("ValuesOpacity", ui.sbValuesOpacity->value()/100);
 	group.writeEntry("ValuesPrefix", ui.leValuesPrefix->text());
 	group.writeEntry("ValuesSuffix", ui.leValuesSuffix->text());
 	group.writeEntry("ValuesFont", ui.kfrValuesFont->font());
 	group.writeEntry("ValuesColor", ui.kcbValuesColor->color());
 
 	//Filling
 	group.writeEntry("FillingEnabled", ui.chkFillingEnabled->isChecked());
 	group.writeEntry("FillingType", ui.cbFillingType->currentIndex());
 	group.writeEntry("FillingColorStyle", ui.cbFillingColorStyle->currentIndex());
 	group.writeEntry("FillingImageStyle", ui.cbFillingImageStyle->currentIndex());
 	group.writeEntry("FillingBrushStyle", ui.cbFillingBrushStyle->currentIndex());
 	group.writeEntry("FillingFileName", ui.leFillingFileName->text());
 	group.writeEntry("FillingFirstColor", ui.kcbFillingFirstColor->color());
 	group.writeEntry("FillingSecondColor", ui.kcbFillingSecondColor->color());
 	group.writeEntry("FillingOpacity", ui.sbFillingOpacity->value()/100.0);
 
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/LiveDataDock.cpp b/src/kdefrontend/dockwidgets/LiveDataDock.cpp
index 86a81a964..4ed8e903c 100644
--- a/src/kdefrontend/dockwidgets/LiveDataDock.cpp
+++ b/src/kdefrontend/dockwidgets/LiveDataDock.cpp
@@ -1,1695 +1,1695 @@
 /***************************************************************************
 File                 : LiveDataDock.cpp
 Project              : LabPlot
 Description          : Dock widget for live data properties
 --------------------------------------------------------------------
 Copyright            : (C) 2017 by Fabian Kristof (fkristofszabolcs@gmail.com)
 Copyright            : (C) 2018 by Kovacs Ferencz (kferike98@gmail.com)
 Copyright            : (C) 2018 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 "LiveDataDock.h"
 #include <KLocalizedString>
 #include <QCompleter>
 #include <QString>
 #include <QTimer>
 #include <QTreeWidgetItem>
 #include <QStandardItemModel>
 
 #ifdef HAVE_MQTT
 #include "kdefrontend/widgets/MQTTWillSettingsWidget.h"
 #include <QMessageBox>
 #include <QWidgetAction>
 #include <QMenu>
 #endif
 
 LiveDataDock::LiveDataDock(QWidget* parent) :
 	QWidget(parent),
 	m_paused(false)
   #ifdef HAVE_MQTT
   ,
 	m_searching(true),
 	m_searchTimer(new QTimer()),
 	m_interpretMessage(true),
 	m_previousMQTTClient(nullptr)
   #endif
 {
 	ui.setupUi(this);
 
 	ui.bUpdateNow->setIcon(QIcon::fromTheme(QLatin1String("view-refresh")));
 
 	connect(ui.bPausePlayReading, &QPushButton::clicked, this, &LiveDataDock::pauseContinueReading);
 	connect(ui.bUpdateNow, &QPushButton::clicked, this, &LiveDataDock::updateNow);
 	connect(ui.sbUpdateInterval, static_cast<void (QSpinBox::*) (int)>(&QSpinBox::valueChanged), this, &LiveDataDock::updateIntervalChanged);
 
 	connect(ui.sbKeepNValues, static_cast<void (QSpinBox::*) (int)>(&QSpinBox::valueChanged), this, &LiveDataDock::keepNValuesChanged);
 	connect(ui.sbSampleSize, static_cast<void (QSpinBox::*) (int)>(&QSpinBox::valueChanged), this, &LiveDataDock::sampleSizeChanged);
 	connect(ui.cbUpdateType, static_cast<void (QComboBox::*) (int)>(&QComboBox::currentIndexChanged), this, &LiveDataDock::updateTypeChanged);
 	connect(ui.cbReadingType, static_cast<void (QComboBox::*) (int)>(&QComboBox::currentIndexChanged), this, &LiveDataDock::readingTypeChanged);
 
 #ifdef HAVE_MQTT
 	m_searchTimer->setInterval(10000);
 
 	connect(this, &LiveDataDock::newTopic, this, &LiveDataDock::setTopicCompleter);
 	connect(m_searchTimer, &QTimer::timeout, this, &LiveDataDock::topicTimeout);
 	connect(ui.bSubscribe, &QPushButton::clicked, this, &LiveDataDock::addSubscription);
 	connect(ui.bUnsubscribe, &QPushButton::clicked, this, &LiveDataDock::removeSubscription);
 	connect(ui.bWillUpdateNow, &QPushButton::clicked, this, &LiveDataDock::willUpdateNow);
 	connect(ui.leTopics, &QLineEdit::textChanged, this, &LiveDataDock::scrollToTopicTreeItem);
 	connect(ui.leSubscriptions, &QLineEdit::textChanged, this, &LiveDataDock::scrollToSubsriptionTreeItem);
 	connect(ui.bWillSettings, &QPushButton::clicked, this, &LiveDataDock::showWillSettings);
 
 	ui.bSubscribe->setIcon(ui.bSubscribe->style()->standardIcon(QStyle::SP_ArrowRight));
 	ui.bSubscribe->setToolTip(i18n("Subscribe selected topics"));
 	ui.bUnsubscribe->setIcon(ui.bUnsubscribe->style()->standardIcon(QStyle::SP_ArrowLeft));
 	ui.bUnsubscribe->setToolTip(i18n("Unsubscribe selected topics"));
 	ui.bWillSettings->setToolTip(i18n("Manage MQTT connection's will settings"));
 	ui.bWillSettings->setIcon(ui.bWillSettings->style()->standardIcon(QStyle::SP_FileDialogDetailedView));
 #endif
 }
 
 LiveDataDock::~LiveDataDock() {
 #ifdef HAVE_MQTT
 	delete m_searchTimer;
 	QMapIterator<QString, QMqttClient*> clients(m_clients);
 	while(clients.hasNext()) {
 		clients.next();
 		delete clients.value();
 	}
 #endif
 }
 
 #ifdef HAVE_MQTT
 /*!
  * \brief Sets the MQTTClients of this dock widget
  * \param clients
  */
 void LiveDataDock::setMQTTClients(const QList<MQTTClient *> &clients) {
 	m_liveDataSources.clear();
 	m_mqttClients.clear();
 	m_mqttClients = clients;
 	const MQTTClient* const fmc = clients.at(0);
 
 	ui.sbUpdateInterval->setValue(fmc->updateInterval());
 	ui.cbUpdateType->setCurrentIndex(static_cast<int>(fmc->updateType()));
 	ui.cbReadingType->setCurrentIndex(static_cast<int>(fmc->readingType()));
 
 	if (fmc->updateType() == MQTTClient::UpdateType::NewData) {
 		ui.lUpdateInterval->hide();
 		ui.sbUpdateInterval->hide();
 	}
 
 	if (fmc->isPaused()) {
 		ui.bPausePlayReading->setText(i18n("Continue reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-record")));
 	} else {
 		ui.bPausePlayReading->setText(i18n("Pause reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-playback-pause")));
 	}
 
 	ui.sbKeepNValues->setValue(fmc->keepNValues());
 	ui.sbKeepNValues->setEnabled(true);
 
 	if (fmc->readingType() == MQTTClient::ReadingType::TillEnd) {
 		ui.lSampleSize->hide();
 		ui.sbSampleSize->hide();
 	} else
 		ui.sbSampleSize->setValue(fmc->sampleSize());
 
 	// disable "whole file" option
 	const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
 	QStandardItem* item = model->item(LiveDataSource::ReadingType::WholeFile);
 	item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 	//show MQTT connected options
 	ui.gbManageSubscriptions->show();
 	ui.bSubscribe->show();
 	ui.bUnsubscribe->show();
 	ui.twTopics->show();
 	ui.leTopics->show();
 	ui.lTopicSearch->show();
 	ui.twSubscriptions->show();
 	ui.lQoS->show();
 	ui.cbQoS->show();
 	ui.lWillSettings->show();
 	ui.bWillSettings->show();
 
 	//if there isn't a client with this hostname we instantiate a new one
 	if(m_clients[fmc->clientHostName()] == nullptr) {
 		m_clients[fmc->clientHostName()] = new QMqttClient();
 
 		connect(fmc, &MQTTClient::clientAboutToBeDeleted, this, &LiveDataDock::removeClient);
 
 		connect(m_clients[fmc->clientHostName()], &QMqttClient::connected, this, &LiveDataDock::onMQTTConnect);
 		connect(m_clients[fmc->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceived);
 
 		m_clients[fmc->clientHostName()]->setHostname(fmc->clientHostName());
 		m_clients[fmc->clientHostName()]->setPort(fmc->clientPort());
 
 		if(fmc->MQTTUseAuthentication()) {
 			m_clients[fmc->clientHostName()]->setUsername(fmc->clientUserName());
 			m_clients[fmc->clientHostName()]->setPassword(fmc->clientPassword());
 		}
 
 		if(fmc->MQTTUseID()) {
 			m_clients[fmc->clientHostName()]->setClientId(fmc->clientID());
 		}
 
 		m_clients[fmc->clientHostName()]->connectToHost();
 	}
 
 	if(m_previousMQTTClient == nullptr) {
 		connect(fmc, &MQTTClient::MQTTSubscribed, this, &LiveDataDock::fillSubscriptions);
 
 		//Fill the subscription tree(useful if the MQTTClient was loaded)
 		QVector<QString> topics = fmc->topicNames();
 		for(int i = 0; i < topics.size(); ++i) {
 			addTopicToTree(topics[i]);
 		}
 		fillSubscriptions();
 	}
 
 	//if the previous MQTTClient's host name was different from the current one we have to disconnect some slots
 	//and clear the tree widgets
 	else if(m_previousMQTTClient->clientHostName() != fmc->clientHostName()) {
 		disconnect(m_previousMQTTClient, &MQTTClient::MQTTSubscribed, this, &LiveDataDock::fillSubscriptions);
 		disconnect(m_clients[m_previousMQTTClient->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceived);
 		connect(m_clients[m_previousMQTTClient->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceivedInBackground);
 
 		disconnect(m_clients[fmc->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceivedInBackground);
 
 		ui.twTopics->clear();
 		//repopulating the tree widget with the already known topics of the client
 		for(int i = 0; i < m_addedTopics[fmc->clientHostName()].size(); ++i) {
 			addTopicToTree(m_addedTopics[fmc->clientHostName()].at(i));
 		}
 
 		//fill subscriptions tree widget
 		ui.twSubscriptions->clear();
 		fillSubscriptions();
 
 		connect(fmc, &MQTTClient::MQTTSubscribed, this, &LiveDataDock::fillSubscriptions);
 		connect(m_clients[fmc->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceived);
 	}
 
 	if(fmc->willUpdateType() == MQTTClient::WillUpdateType::OnClick && fmc->MQTTWillUse())
 		ui.bWillUpdateNow->show();
 
 	m_previousMQTTClient = fmc;
 }
 #endif
 
 /*!
  * \brief Sets the live data sources of this dock widget
  * \param sources
  */
 void LiveDataDock::setLiveDataSources(const QList<LiveDataSource*>& sources) {
 #ifdef HAVE_MQTT
 	m_mqttClients.clear();
 #endif
 	m_liveDataSources = sources;
 	const LiveDataSource* const fds = sources.at(0);
 	const LiveDataSource::SourceType sourceType = fds->sourceType();
 	const LiveDataSource::ReadingType readingType = fds->readingType();
 	const LiveDataSource::UpdateType updateType = fds->updateType();
 	ui.sbUpdateInterval->setValue(fds->updateInterval());
 	ui.cbUpdateType->setCurrentIndex(static_cast<int>(updateType));
 	ui.cbReadingType->setCurrentIndex(static_cast<int>(readingType));
 
 	if (updateType == LiveDataSource::UpdateType::NewData) {
 		ui.lUpdateInterval->hide();
 		ui.sbUpdateInterval->hide();
 	}
 
 	if (fds->isPaused()) {
 		ui.bPausePlayReading->setText(i18n("Continue Reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-record")));
 	} else {
 		ui.bPausePlayReading->setText(i18n("Pause Reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-playback-pause")));
 	}
 
 	ui.sbKeepNValues->setValue(fds->keepNValues());
 
 	// disable "whole file" when having no file (i.e. socket or port)
-	auto model = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
+	auto* model = qobject_cast<const QStandardItemModel*>(ui.cbReadingType->model());
 	QStandardItem* item = model->item(LiveDataSource::ReadingType::WholeFile);
 	if (sourceType == LiveDataSource::SourceType::FileOrPipe)
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	else
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 
 	if (sourceType == LiveDataSource::SourceType::NetworkTcpSocket || sourceType == LiveDataSource::SourceType::LocalSocket || sourceType == LiveDataSource::SourceType::SerialPort
 			|| readingType == LiveDataSource::ReadingType::TillEnd || readingType == LiveDataSource::ReadingType::WholeFile) {
 		ui.lSampleSize->hide();
 		ui.sbSampleSize->hide();
 	} else {
 		ui.sbSampleSize->setValue(fds->sampleSize());
 	}
 
 	// disable "on new data"-option if not available
 	model = qobject_cast<const QStandardItemModel*>(ui.cbUpdateType->model());
 	item = model->item(LiveDataSource::UpdateType::NewData);
 	if (sourceType == LiveDataSource::SourceType::NetworkTcpSocket || sourceType == LiveDataSource::SourceType::NetworkUdpSocket ||
 			sourceType == LiveDataSource::SourceType::SerialPort) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEnabled));
 	} else {
 		item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
 	}
 
 	ui.bWillSettings->hide();
 	ui.lWillSettings->hide();
 	ui.bWillUpdateNow->hide();
 	ui.bSubscribe->hide();
 	ui.bUnsubscribe->hide();
 	ui.twTopics->hide();
 	ui.leTopics->hide();
 	ui.lTopicSearch->hide();
 	ui.twSubscriptions->hide();
 	ui.gbManageSubscriptions->hide();
 	ui.lQoS->hide();
 	ui.cbQoS->hide();
 }
 
 /*!
  * \brief Modifies the sample size of the live data sources or MQTTClient objects
  * \param sampleSize
  */
 void LiveDataDock::sampleSizeChanged(int sampleSize) {
 	if(!m_liveDataSources.isEmpty()) {
 		for (auto* source : m_liveDataSources)
 			source->setSampleSize(sampleSize);
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->setSampleSize(sampleSize);
 	}
 #endif
 }
 
 /*!
  * \brief Updates the live data sources now
  */
 void LiveDataDock::updateNow() {
 	if(!m_liveDataSources.isEmpty()) {
 		for (auto* source : m_liveDataSources)
 			source->updateNow();
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->updateNow();
 	}
 #endif
 }
 
 /*!
  * \brief LiveDataDock::updateTypeChanged
  * \param idx
  */
 void LiveDataDock::updateTypeChanged(int idx) {
 	if(!m_liveDataSources.isEmpty())  {
 		DEBUG("LiveDataDock::updateTypeChanged()");
 		const auto type = static_cast<LiveDataSource::UpdateType>(idx);
 
 		switch (type) {
 		case LiveDataSource::UpdateType::TimeInterval:
 			ui.lUpdateInterval->show();
 			ui.sbUpdateInterval->show();
 			ui.lSampleSize->show();
 			ui.sbSampleSize->show();
 
-			for (auto* source: m_liveDataSources) {
+			for (auto* source : m_liveDataSources) {
 				source->setUpdateType(type);
 				source->setUpdateInterval(ui.sbUpdateInterval->value());
 				source->setFileWatched(false);
 			}
 			break;
 		case LiveDataSource::UpdateType::NewData:
 			ui.lUpdateInterval->hide();
 			ui.sbUpdateInterval->hide();
 			ui.lSampleSize->hide();
 			ui.sbSampleSize->hide();
 
-			for (auto* source: m_liveDataSources) {
+			for (auto* source : m_liveDataSources) {
 				source->setFileWatched(true);
 				source->setUpdateType(type);
 			}
 		}
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		DEBUG("LiveDataDock::updateTypeChanged()");
 		const MQTTClient::UpdateType type = static_cast<MQTTClient::UpdateType>(idx);
 
 		if (type == MQTTClient::UpdateType::TimeInterval) {
 			ui.lUpdateInterval->show();
 			ui.sbUpdateInterval->show();
 
 			for (auto* client : m_mqttClients) {
 				client->setUpdateType(type);
 				client->setUpdateInterval(ui.sbUpdateInterval->value());
 			}
 		} else if (type == MQTTClient::UpdateType::NewData) {
 			ui.lUpdateInterval->hide();
 			ui.sbUpdateInterval->hide();
 
 			for (auto* client : m_mqttClients) {
 				client->setUpdateType(type);
 			}
 		}
 	}
 #endif
 }
 
 /*!
  * \brief Handles the change of the reading type in the dock widget
  * \param idx
  */
 void LiveDataDock::readingTypeChanged(int idx) {
 	if(!m_liveDataSources.isEmpty())  {
 		const auto type = static_cast<LiveDataSource::ReadingType>(idx);
 		const LiveDataSource* const fds = m_liveDataSources.at(0);
 		const LiveDataSource::SourceType sourceType = fds->sourceType();
 		const LiveDataSource::UpdateType updateType = fds->updateType();
 
 		if (sourceType == LiveDataSource::SourceType::NetworkTcpSocket || sourceType == LiveDataSource::SourceType::LocalSocket || sourceType == LiveDataSource::SourceType::SerialPort
 				|| type == LiveDataSource::ReadingType::TillEnd || type == LiveDataSource::ReadingType::WholeFile
 				|| updateType == LiveDataSource::UpdateType::NewData) {
 			ui.lSampleSize->hide();
 			ui.sbSampleSize->hide();
 		} else {
 			ui.lSampleSize->show();
 			ui.sbSampleSize->show();
 		}
 
 		for (auto* source : m_liveDataSources)
 			source->setReadingType(type);
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		MQTTClient::ReadingType type = static_cast<MQTTClient::ReadingType>(idx);
 
 		if (type == MQTTClient::ReadingType::TillEnd) {
 			ui.lSampleSize->hide();
 			ui.sbSampleSize->hide();
 		} else {
 			ui.lSampleSize->show();
 			ui.sbSampleSize->show();
 		}
 
 		for (auto* client : m_mqttClients)
 			client->setReadingType(type);
 	}
 #endif
 }
 
 /*!
  * \brief Modifies the update interval of the live data sources
  * \param updateInterval
  */
 void LiveDataDock::updateIntervalChanged(int updateInterval) {
 	if(!m_liveDataSources.isEmpty())  {
 		for (auto* source : m_liveDataSources)
 			source->setUpdateInterval(updateInterval);
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->setUpdateInterval(updateInterval);
 	}
 #endif
 }
 
 /*!
  * \brief Modifies the number of samples to keep in each of the live data sources
  * \param keepNValues
  */
 void LiveDataDock::keepNValuesChanged(const int keepNValues) {
 	if(!m_liveDataSources.isEmpty())  {
 		for (auto* source : m_liveDataSources)
 			source->setKeepNValues(keepNValues);
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->setKeepNValues(keepNValues);
 	}
 #endif
 }
 
 /*!
  * \brief Pauses the reading of the live data source
  */
 void LiveDataDock::pauseReading() {
 	if(!m_liveDataSources.isEmpty())  {
 		for (auto* source: m_liveDataSources)
 			source->pauseReading();
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->pauseReading();
 	}
 #endif
 }
 
 /*!
  * \brief Continues the reading of the live data source
  */
 void LiveDataDock::continueReading() {
 	if(!m_liveDataSources.isEmpty())  {
-		for (auto* source: m_liveDataSources)
+		for (auto* source : m_liveDataSources)
 			source->continueReading();
 	}
 #ifdef HAVE_MQTT
 	else if (!m_mqttClients.isEmpty()) {
 		for (auto* client : m_mqttClients)
 			client->continueReading();
 	}
 #endif
 }
 
 /*!
  * \brief Handles the pausing/continuing of reading of the live data source
  */
 void LiveDataDock::pauseContinueReading() {
 	m_paused = !m_paused;
 
 	if (m_paused) {
 		pauseReading();
 		ui.bPausePlayReading->setText(i18n("Continue Reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-record")));
 	} else {
 		continueReading();
 		ui.bPausePlayReading->setText(i18n("Pause Reading"));
 		ui.bPausePlayReading->setIcon(QIcon::fromTheme(QLatin1String("media-playback-pause")));
 	}
 }
 
 #ifdef HAVE_MQTT
 
 /*!
  *\brief called when use will message checkbox's state is changed in the will settings widget,
  * Sets the mqttUseWill according to state for every client in m_mqttClients
  *
  * \param state the state of the checbox
  */
 void LiveDataDock::useWillMessage(int state) {
 	qDebug()<<"Use will message: " <<state;
 
 	if(state == Qt::Checked) {
-		for (auto* source: m_mqttClients)
+		for (auto* source : m_mqttClients)
 			source->setMQTTWillUse(true);
 
 		if (m_mqttClients.first()->willUpdateType() == MQTTClient::WillUpdateType::OnClick)
 			ui.bWillUpdateNow->show();
 
 	} else if (state == Qt::Unchecked) {
-		for (auto* source: m_mqttClients)
+		for (auto* source : m_mqttClients)
 			source->setMQTTWillUse(false);
 
 		ui.bWillUpdateNow->hide();
 	}
 }
 
 /*!
  *\brief called when will message's QoS is changed in the will settings widget
  * sets the will QoS level for every client in m_mqttClients
  *
  * \param QoS the QoS level of the will message
  */
 void LiveDataDock::willQoSChanged(int QoS) {
-	for (auto* source: m_mqttClients)
+	for (auto* source : m_mqttClients)
 		source->setWillQoS(QoS);
 }
 
 /*!
  *\brief called when will message's retain flag is changed in the will settings widget
  * sets the retain flag for the will message in every client in m_mqttClients
  *
  * \param state the state of the will retain chechbox
  */
 void LiveDataDock::willRetainChanged(int state) {
 	if(state == Qt::Checked) {
-		for (auto* source: m_mqttClients)
+		for (auto* source : m_mqttClients)
 			source->setWillRetain(true);
 	} else if (state == Qt::Unchecked) {
-		for (auto* source: m_mqttClients)
+		for (auto* source : m_mqttClients)
 			source->setWillRetain(false);
 	}
 }
 
 /*!
  *\brief called when will topic combobox's current item is changed in the will settings widget
  * sets the will topic for every client in m_mqttClients
  *
  * \param topic the current text of cbWillTopic
  */
 void LiveDataDock::willTopicChanged(const QString& topic) {
-	for (auto* source: m_mqttClients) {
+	for (auto* source : m_mqttClients) {
 		if(source->willTopic() != topic)
 			source->clearLastMessage();
 
 		source->setWillTopic(topic);
 	}
 }
 
 /*!
  *\brief called when the selected will message type is changed in the will settings widget
  * sets the will message type for every client in m_mqttClients
  *
  * \param type the selected will message type
  */
 void LiveDataDock::willMessageTypeChanged(int type) {
-	for (auto* source: m_mqttClients)
+	for (auto* source : m_mqttClients)
 		source->setWillMessageType(static_cast<MQTTClient::WillMessageType> (type));
 }
 
 /*!
  *\brief called when the will own message is changed in the will settings widget
  * sets the will own message for every client in m_mqttClients
  *
  * \param message the will message given by the user
  */
 void LiveDataDock::willOwnMessageChanged(const QString& message) {
-	for (auto* source: m_mqttClients)
+	for (auto* source : m_mqttClients)
 		source->setWillOwnMessage(message);
 }
 
 /*!
  *\brief called when the selected update type for the will message is changed in the will settings widget
  * sets the will update type for every client in m_mqttClients
  *
  * \param type the selected will update type
  */
 void LiveDataDock::willUpdateTypeChanged(int updateType) {
-	for (auto* source: m_mqttClients)
+	for (auto* source : m_mqttClients)
 		source->setWillUpdateType(static_cast<MQTTClient::WillUpdateType>(updateType));
 
 	if(static_cast<MQTTClient::WillUpdateType>(updateType) == MQTTClient::WillUpdateType::TimePeriod) {
 		ui.bWillUpdateNow->hide();
 
-		for (auto* source: m_mqttClients) {
+		for (auto* source : m_mqttClients) {
 			source->startWillTimer();
 		}
 	} else if (static_cast<MQTTClient::WillUpdateType>(updateType) == MQTTClient::WillUpdateType::OnClick) {
 		ui.bWillUpdateNow->show();
 
 		//if update type is on click we stop the will timer
-		for (auto* source: m_mqttClients)
+		for (auto* source : m_mqttClients)
 			source->stopWillTimer();
 	}
 }
 
 /*!
  *\brief called when the will update now button is pressed
  * updates the will message of every client in m_mqttClients
  */
 void LiveDataDock::willUpdateNow() {
-	for (auto* source: m_mqttClients)
+	for (auto* source : m_mqttClients)
 		source->updateWillMessage();
 }
 
 /*!
  *\brief called when the update interval for will message is changed in the will settings widget
  * sets the will update interval for every client in m_mqttClients, then starts the will timer for each one
  *
  * \param interval the new will update interval
  */
 void LiveDataDock::willUpdateIntervalChanged(int interval) {
-	for (auto* source: m_mqttClients) {
+	for (auto* source : m_mqttClients) {
 		source->setWillTimeInterval(interval);
 		source->startWillTimer();
 	}
 }
 
 /*!
  *\brief called when the will statistics are changed in the will settings widget
  * adds or removes the statistic represented by the index from every client in m_mqttClients
  */
 void LiveDataDock::statisticsChanged(int index) {
 	bool useStatistic = m_mqttClients.first()->willStatistics()[index];
 
 	//if it's checked we add it
 	if(!useStatistic) {
 		if(index >= 0) {
-			for (auto* source: m_mqttClients)
+			for (auto* source : m_mqttClients)
 				source->addWillStatistics(static_cast<MQTTClient::WillStatistics>(index) );
 		}
 	}
 	//otherwise remove it
 	else {
 		if(index >= 0){
-			for (auto* source: m_mqttClients)
+			for (auto* source : m_mqttClients)
 				source->removeWillStatistics(static_cast<MQTTClient::WillStatistics>(index) );
 		}
 	}
 }
 
 /*!
  *\brief called when the client connects to the broker successfully, it subscribes to every topic (# wildcard)
  * in order to later list every available topic
  */
 void LiveDataDock::onMQTTConnect() {
 	QMqttTopicFilter globalFilter{"#"};
 	QMqttSubscription * subscription = m_clients[m_mqttClients.first()->clientHostName()]->subscribe(globalFilter, 1);
 	if(!subscription)
 		qDebug()<<"Couldn't make global subscription in LiveDataDock";
 }
 
 /*!
  *\brief called when the client receives a message
  * if the message arrived from a new topic, the topic is put in twTopics
  */
 void LiveDataDock::mqttMessageReceived(const QByteArray& message, const QMqttTopicName& topic) {
 	Q_UNUSED(message)
 	if(!m_addedTopics[m_mqttClients.first()->clientHostName()].contains(topic.name())) {
 		m_addedTopics[m_mqttClients.first()->clientHostName()].push_back(topic.name());
 		addTopicToTree(topic.name());
 	}
 }
 
 /*!
  *\brief called when the subscribe button is pressed
  * subscribes to the topic represented by the current item of twTopics in every client from m_mqttClients
  */
 void LiveDataDock::addSubscription() {
 	QString name;
 	QTreeWidgetItem *item = ui.twTopics->currentItem();
 	if(item != nullptr) {
 		QTreeWidgetItem *tempItem = item;
 
 		//determine the topic name that the current item represents
 		name.prepend(item->text(0));
 		if(item->childCount() != 0)
 			name.append("/#");
 		while(tempItem->parent() != nullptr) {
 			tempItem = tempItem->parent();
 			name.prepend(tempItem->text(0) + '/');
 		}
 
 		//check if the subscription already exists
 		QList<QTreeWidgetItem *> topLevelList = ui.twSubscriptions->findItems(name, Qt::MatchExactly);
 		if(topLevelList.isEmpty() || topLevelList.first()->parent() != nullptr) {
 			qDebug() << "LiveDataDock: start to add new subscription: " << name;
 			bool foundSuperior = false;
 
 			for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 				//if the new subscriptions contains an already existing one, we remove the inferior one
 				if(checkTopicContains(name, ui.twSubscriptions->topLevelItem(i)->text(0))
 						&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 					ui.twSubscriptions->topLevelItem(i)->takeChildren();
 					ui.twSubscriptions->takeTopLevelItem(i);
 					i--;
 					continue;
 				}
 
 				//if there is a subscription containing the new one we set foundSuperior true
 				if(checkTopicContains(ui.twSubscriptions->topLevelItem(i)->text(0), name)
 						&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 					foundSuperior = true;
 					qDebug()<<"Can't add "<<name<<" because found superior: "<< ui.twSubscriptions->topLevelItem(i)->text(0);
 					break;
 				}
 			}
 
 			//if there wasn't a superior subscription we can subscribe to the new topic
 			if(!foundSuperior) {
 				QStringList toplevelName;
 				toplevelName.push_back(name);
 				QTreeWidgetItem* newTopLevelItem = new QTreeWidgetItem(toplevelName);
 				ui.twSubscriptions->addTopLevelItem(newTopLevelItem);
 
 				if(name.endsWith('#')) {
 					//adding every topic that the subscription contains to twSubscriptions
 					addSubscriptionChildren(item, newTopLevelItem);
 				}
 
 				//subscribe in every MQTTClient
-				for (auto* source: m_mqttClients) {
+				for (auto* source : m_mqttClients) {
 					source->addMQTTSubscription(name, ui.cbQoS->currentIndex());
 				}
 
 				if(name.endsWith('#')) {
 					//if an already existing subscription contains a topic that the new subscription also contains
 					//we decompose the already existing subscription
 					//by unsubscribing from its topics, that are present in the new subscription as well
 					QStringList nameList = name.split('/', QString::SkipEmptyParts);
 					QString root = nameList.first();
 					QVector<QTreeWidgetItem*> children;
 					for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 						if(ui.twSubscriptions->topLevelItem(i)->text(0).startsWith(root)
 								&& name != ui.twSubscriptions->topLevelItem(i)->text(0)) {
 							children.clear();
 
 							//get the "leaf" children of the inspected subscription
 							findSubscriptionLeafChildren(children, ui.twSubscriptions->topLevelItem(i));
 							for(int j = 0; j < children.size(); ++j) {
 								if(checkTopicContains(name, children[j]->text(0))) {
 									//if the new subscription contains a topic, we unsubscribe from it
 									QTreeWidgetItem* unsubscribeItem = children[j];
 									while(unsubscribeItem->parent() != nullptr) {
 										for(int i = 0; i < unsubscribeItem->parent()->childCount(); ++i) {
 
 											if(unsubscribeItem->text(0) != unsubscribeItem->parent()->child(i)->text(0)) {
 												//add topic as subscription to every client
-												for (auto* source: m_mqttClients) {
+												for (auto* source : m_mqttClients) {
 													source->addBeforeRemoveSubscription(unsubscribeItem->parent()->child(i)->text(0), ui.cbQoS->currentIndex());
 												}
 												//also add it to twSubscriptions
 												ui.twSubscriptions->addTopLevelItem(unsubscribeItem->parent()->takeChild(i));
 												i--;
 											} else {
 												//before we remove the topic, we reparent it to the new subscription
 												//so no data is lost
-												for (auto* source: m_mqttClients) {
+												for (auto* source : m_mqttClients) {
 													source->reparentTopic(unsubscribeItem->text(0), name);
 												}
 											}
 										}
 										unsubscribeItem = unsubscribeItem->parent();
 									}
 
 									qDebug()<<"Remove: "<<unsubscribeItem->text(0);
 									//Remove topic/subscription
-									for (auto* source: m_mqttClients) {
+									for (auto* source : m_mqttClients) {
 										source->removeMQTTSubscription(unsubscribeItem->text(0));
 									}
 
 									ui.twSubscriptions->takeTopLevelItem(ui.twSubscriptions->indexOfTopLevelItem(unsubscribeItem));
 								}
 							}
 						}
 					}
 				}
 
 				manageCommonLevelSubscriptions();
 				updateSubscriptionCompleter();
 
 				if(!ui.bWillSettings->isEnabled())
 					ui.bWillSettings->setEnabled(true);
 			} else {
 				QMessageBox::warning(this, "Warning", "You already subscribed to a topic containing this one");
 			}
 		}
 		else
 			QMessageBox::warning(this, "Warning", "You already subscribed to this topic");
 	}
 	else
 		QMessageBox::warning(this, "Warning", "You didn't select any item from the Tree Widget");
 }
 
 /*!
  *\brief called when the unsubscribe button is pressed
  * unsubscribes from the topic represented by the current item of twSubscription in every client from m_mqttClients
  */
 void LiveDataDock::removeSubscription() {
 	QTreeWidgetItem* unsubscribeItem = ui.twSubscriptions->currentItem();
 
 	if(unsubscribeItem != nullptr) {
 		qDebug() << "LiveDataDock: unsubscribe from " << unsubscribeItem->text(0);
 
 		//if it is a top level item, meaning a topic that we really subscribed to(not one that belongs to a subscription)
 		//we can simply unsubscribe from it
 		if(unsubscribeItem->parent() == nullptr) {
-			for (auto* source: m_mqttClients) {
+			for (auto* source : m_mqttClients) {
 				source->removeMQTTSubscription(unsubscribeItem->text(0));
 			}
 			ui.twSubscriptions->takeTopLevelItem(ui.twSubscriptions->indexOfTopLevelItem(unsubscribeItem));
 		}
 		//otherwise we remove the selected item, but subscribe to every other topic, that was contained by
 		//the selected item's parent subscription(top level item of twSubscriptions)
 		else{
 			while(unsubscribeItem->parent() != nullptr) {
 				for(int i = 0; i < unsubscribeItem->parent()->childCount(); ++i) {
 					if(unsubscribeItem->text(0) != unsubscribeItem->parent()->child(i)->text(0)) {
 						//add topic as subscription to every client
-						for (auto* source: m_mqttClients) {
+						for (auto* source : m_mqttClients) {
 							source->addBeforeRemoveSubscription(unsubscribeItem->parent()->child(i)->text(0), ui.cbQoS->currentIndex());
 						}
 						ui.twSubscriptions->addTopLevelItem(unsubscribeItem->parent()->takeChild(i));
 						i--;
 					}
 				}
 				unsubscribeItem = unsubscribeItem->parent();
 			}
 
 			//remove topic/subscription from every client
-			for (auto* source: m_mqttClients) {
+			for (auto* source : m_mqttClients) {
 				source->removeMQTTSubscription(unsubscribeItem->text(0));
 			}
 			ui.twSubscriptions->takeTopLevelItem(ui.twSubscriptions->indexOfTopLevelItem(unsubscribeItem));
 
 			//check if any common topics were subscribed, if possible merge them
 			manageCommonLevelSubscriptions();
 		}
 
 		if(ui.twSubscriptions->topLevelItemCount() <= 0)
 			ui.bWillSettings->setEnabled(false);
 
 		updateSubscriptionCompleter();
 	} else
 		QMessageBox::warning(this, "Warning", "You didn't select any item from the Tree Widget");
 }
 
 /*!
  *\brief called when a new topic is added to the tree(twTopics)
  * appends the topic's root to the topicList if it isn't in the list already
  * then sets the completer for leTopics
  */
 void LiveDataDock::setTopicCompleter(const QString& topicName) {
 	if(!m_searching) {
 		QStringList list = topicName.split('/', QString::SkipEmptyParts);
 		QString topic;
 		if(!list.isEmpty()) {
 			topic = list.at(0);
 		} else
 			topic = topicName;
 
 		if(!m_topicList[m_mqttClients.first()->clientHostName()].contains(topic)) {
 			m_topicList[m_mqttClients.first()->clientHostName()].append(topic);
 			m_topicCompleter = new QCompleter(m_topicList[m_mqttClients.first()->clientHostName()], this);
 			m_topicCompleter->setCompletionMode(QCompleter::PopupCompletion);
 			m_topicCompleter->setCaseSensitivity(Qt::CaseSensitive);
 			ui.leTopics->setCompleter(m_topicCompleter);
 		}
 	}
 }
 
 /*!
  *\brief Updates the completer for leSubscriptions
  */
 void LiveDataDock::updateSubscriptionCompleter() {
 	QStringList subscriptionList;
 	QVector<QString> subscriptions = m_mqttClients.first()->MQTTSubscriptions();
 
 	if(!subscriptions.isEmpty()) {
 		for(int i = 0; i < subscriptions.size(); ++i) {
 			subscriptionList.append(subscriptions[i]);
 		}
 
 		m_subscriptionCompleter = new QCompleter(subscriptionList, this);
 		m_subscriptionCompleter->setCompletionMode(QCompleter::PopupCompletion);
 		m_subscriptionCompleter->setCaseSensitivity(Qt::CaseSensitive);
 		ui.leSubscriptions->setCompleter(m_subscriptionCompleter);
 	} else {
 		ui.leSubscriptions->setCompleter(nullptr);
 	}
 }
 
 /*!
  *\brief called when 10 seconds passed since the last time the user searched for a certain root in twTopics
  * enables updating the completer for le
  */
 void LiveDataDock::topicTimeout() {
 	m_searching = false;
 	m_searchTimer->stop();
 }
 
 /*!
  *\brief called when a new the host name of the MQTTClients from m _mqttClients changes
  * or when the MQTTClients initialize their subscriptions
  * Fills twSubscriptions with the subscriptions of the MQTTClient
  */
 void LiveDataDock::fillSubscriptions() {
 	const MQTTClient* const fmc = m_mqttClients.at(0);
 
 	ui.twSubscriptions->clear();
 
 	QVector<QString> subscriptions = fmc->MQTTSubscriptions();
 	for (int i = 0; i < subscriptions.count(); ++i) {
 		QStringList name;
 		name.append(subscriptions[i]);
 
 		bool found = false;
 		for(int j = 0; j < ui.twSubscriptions->topLevelItemCount(); ++j) {
 			if(ui.twSubscriptions->topLevelItem(j)->text(0) == subscriptions[i]) {
 				found = true;
 				break;
 			}
 		}
 
 		if(!found) {
 			//Add the subscription to the tree widget
 			QTreeWidgetItem* newItem = new QTreeWidgetItem(name);
 			ui.twSubscriptions->addTopLevelItem(newItem);
 			name.clear();
 			name = subscriptions[i].split('/', QString::SkipEmptyParts);
 
 			//find the corresponding "root" item in twTopics
 			QTreeWidgetItem* topic = nullptr;
 			for(int j = 0; j < ui.twTopics->topLevelItemCount(); ++j) {
 				if(ui.twTopics->topLevelItem(j)->text(0) == name[0]) {
 					topic = ui.twTopics->topLevelItem(j);
 					break;
 				}
 			}
 
 			//restore the children of the subscription
 			if(topic != nullptr && topic->childCount() > 0) {
 				restoreSubscriptionChildren(topic, newItem, name, 1);
 			}
 		}
 	}
 	m_searching = false;
 }
 
 /*!
  *\brief Checks if a topic contains another one
  *
  * \param superior the name of a topic
  * \param inferior the name of a topic
  * \return	true if superior is equal to or contains(if superior contains wildcards) inferior,
  *			false otherwise
  */
 bool LiveDataDock::checkTopicContains(const QString &superior, const QString &inferior) {
 	if (superior == inferior)
 		return true;
 	else {
 		if(superior.contains('/')) {
 			QStringList superiorList = superior.split('/', QString::SkipEmptyParts);
 			QStringList inferiorList = inferior.split('/', QString::SkipEmptyParts);
 
 			//a longer topic can't contain a shorter one
 			if(superiorList.size() > inferiorList.size())
 				return false;
 
 			bool ok = true;
 			for(int i = 0; i < superiorList.size(); ++i) {
 				if(superiorList.at(i) != inferiorList.at(i)) {
 					if((superiorList.at(i) != "+") &&
 							!(superiorList.at(i) == '#' && i == superiorList.size() - 1)) {
 						//if the two topics differ, and the superior's current level isn't + or #(which can be only in the last position)
 						//then superior can't contain inferior
 						ok = false;
 						break;
 					} else if(i == superiorList.size() - 1 && (superiorList.at(i) == "+" && inferiorList.at(i) == '#') ) {
 						//if the two topics differ at the last level
 						//and the superior's current level is + while the inferior's is #(which can be only in the last position)
 						//then superior can't contain inferior
 						ok = false;
 						break;
 					}
 				}
 			}
 			return ok;
 		}
 		return false;
 	}
 }
 
 /*!
  *\brief called when leTopics' text is changed
  *		 if the rootName can be found in twTopics, then we scroll it to the top of the tree widget
  *
  * \param rootName the current text of leTopics
  */
 void LiveDataDock::scrollToTopicTreeItem(const QString& rootName) {
 	m_searching = true;
 	m_searchTimer->start();
 
 	int topItemIdx = -1;
 	for(int i = 0; i< ui.twTopics->topLevelItemCount(); ++i)
 		if(ui.twTopics->topLevelItem(i)->text(0) == rootName) {
 			topItemIdx = i;
 			break;
 		}
 
 	if(topItemIdx >= 0) {
 		ui.twTopics->scrollToItem(ui.twTopics->topLevelItem(topItemIdx), QAbstractItemView::ScrollHint::PositionAtTop);
 	}
 }
 
 /*!
  *\brief called when leSubscriptions' text is changed
  *		 if the rootName can be found in twSubscriptions, then we scroll it to the top of the tree widget
  *
  * \param rootName the current text of leSubscriptions
  */
 void LiveDataDock::scrollToSubsriptionTreeItem(const QString& rootName) {
 	int topItemIdx = -1;
 	for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i)
 		if(ui.twSubscriptions->topLevelItem(i)->text(0) == rootName) {
 			topItemIdx = i;
 			break;
 		}
 
 	if(topItemIdx >= 0) {
 		ui.twSubscriptions->scrollToItem(ui.twSubscriptions->topLevelItem(topItemIdx), QAbstractItemView::ScrollHint::PositionAtTop);
 	}
 }
 
 /*!
  *\brief Returns the "+" wildcard containing topic name, which includes the given topic names
  *
  * \param first the name of a topic
  * \param second the name of a topic
  * \return The name of the common topic, if it exists, otherwise ""
  */
 QString LiveDataDock::checkCommonLevel(const QString& first, const QString& second) {
 	QStringList firstList = first.split('/', QString::SkipEmptyParts);
 	QStringList secondtList = second.split('/', QString::SkipEmptyParts);
 	QString commonTopic = "";
 
 	if(!firstList.isEmpty()) {
 		//the two topics have to be the same size and can't be identic
 		if(firstList.size() == secondtList.size() && (first != second))	{
 
 			//the index where they differ
 			int differIndex = -1;
 			for(int i = 0; i < firstList.size(); ++i) {
 				if(firstList.at(i) != secondtList.at(i)) {
 					differIndex = i;
 					break;
 				}
 			}
 
 			//they can differ at only one level
 			bool differ = false;
 			if(differIndex > 0 && differIndex < firstList.size() -1) {
 				for(int j = differIndex +1; j < firstList.size(); ++j) {
 					if(firstList.at(j) != secondtList.at(j)) {
 						differ = true;
 						break;
 					}
 				}
 			}
 			else
 				differ = true;
 
 			if(!differ)
 			{
 				for(int i = 0; i < firstList.size(); ++i) {
 					if(i != differIndex) {
 						commonTopic.append(firstList.at(i));
 					} else {
 						//we put "+" wildcard at the level where they differ
 						commonTopic.append('+');
 					}
 
 					if(i != firstList.size() - 1)
 						commonTopic.append('/');
 				}
 			}
 		}
 	}
 	qDebug() << "Common topic for " << first << " and "<<second << " is: " << commonTopic;
 	return commonTopic;
 }
 
 /*!
  *\brief Adds to a # wildcard containing topic, every topic present in twTopics that the former topic contains
  *
  * \param topic pointer to the TreeWidgetItem which was selected before subscribing
  * \param subscription pointer to the TreeWidgetItem which represents the new subscirption,
  *		  we add all of the children to this item
  */
 void LiveDataDock::addSubscriptionChildren(QTreeWidgetItem * topic, QTreeWidgetItem * subscription) {
 	//if the topic doesn't have any children we don't do anything
 	if(topic->childCount() > 0) {
 		for(int i = 0; i < topic->childCount(); ++i) {
 			QTreeWidgetItem* temp = topic->child(i);
 			QString name;
 			//if it has children, then we add it as a # wildcrad containing topic
 			if(topic->child(i)->childCount() > 0) {
 				name.append(temp->text(0) + "/#");
 				while(temp->parent() != nullptr) {
 					temp = temp->parent();
 					name.prepend(temp->text(0) + '/');
 				}
 
 			}
 			//if not then we simply add the topic itself
 			else {
 				name.append(temp->text(0));
 				while(temp->parent() != nullptr) {
 					temp = temp->parent();
 					name.prepend(temp->text(0) + '/');
 				}
 			}
 
 			QStringList nameList;
 			nameList.append(name);
 			QTreeWidgetItem* childItem = new QTreeWidgetItem(nameList);
 			subscription->addChild(childItem);
 			//we use the function recursively on the given item
 			addSubscriptionChildren(topic->child(i), childItem);
 		}
 	}
 }
 
 /*!
  *\brief Restores the children of a top level item in twSubscriptions if it contains wildcards
  *
  * \param topic pointer to a top level item in twTopics which represents the root of the subscription topic
  * \param subscription pointer to a top level item in twSubscriptions, this is the item whose children will be restored
  * \param list QStringList containing the levels of the subscription topic
  * \param level the level's number which is being investigated
  */
 void LiveDataDock::restoreSubscriptionChildren(QTreeWidgetItem * topic, QTreeWidgetItem * subscription, const QStringList& list, int level) {
 	if(level < list.size()) {
 		if((level < list.size() - 1) && (list[level] != "+") && (list[level] != '#')) {
 			for(int i = 0; i < topic->childCount(); ++i) {
 				//if the current level isn't + or # wildcard we recursively continue with the next level
 				if(topic->child(i)->text(0) == list[level]) {
 					restoreSubscriptionChildren(topic->child(i), subscription, list, level + 1);
 					break;
 				}
 			}
 		} else if (list[level] == "+") {
 			for(int i = 0; i < topic->childCount(); ++i) {
 				//determine the name of the topic, contained by the subscription
 				QString name;
 				name.append(topic->child(i)->text(0));
 				for(int j = level + 1; j < list.size(); ++j) {
 					name.append('/' + list[j]);
 				}
 				QTreeWidgetItem* temp = topic->child(i);
 				while(temp->parent() != nullptr) {
 					temp = temp->parent();
 					name.prepend(temp->text(0) + '/');
 				}
 
 				//Add the topic as child of the subscription
 				QStringList nameList;
 				nameList.append(name);
 				QTreeWidgetItem* newItem = new QTreeWidgetItem(nameList);
 				subscription->addChild(newItem);
 				//Continue adding children recursively to the new item
 				restoreSubscriptionChildren(topic->child(i), newItem, list, level + 1);
 			}
 		} else if (list[level] == '#') {
 			//add the children of the # wildcard containing subscription
 			addSubscriptionChildren(topic, subscription);
 		}
 	}
 }
 
 /*!
  *\brief Returns the index of level where the two topic names differ, if there is a common topic for them
  *
  * \param first the name of a topic
  * \param second the name of a topic
  * \return The index of the unequal level, if there is a common topic, otherwise -1
  */
 int LiveDataDock::commonLevelIndex(const QString& first, const QString& second) {
 	QStringList firstList = first.split('/', QString::SkipEmptyParts);
 	QStringList secondtList = second.split('/', QString::SkipEmptyParts);
 	QString commonTopic = "";
 	int differIndex = -1;
 
 	if(!firstList.isEmpty()) {
 		//the two topics have to be the same size and can't be identic
 		if(firstList.size() == secondtList.size() && (first != second))	{
 
 			//the index where they differ
 			for(int i = 0; i < firstList.size(); ++i) {
 				if(firstList.at(i) != secondtList.at(i)) {
 					differIndex = i;
 					break;
 				}
 			}
 
 			//they can differ at only one level
 			bool differ = false;
 			if(differIndex > 0) {
 				for(int j = differIndex +1; j < firstList.size(); ++j) {
 					if(firstList.at(j) != secondtList.at(j)) {
 						differ = true;
 						break;
 					}
 				}
 			}
 			else
 				differ = true;
 
 			if(!differ)
 			{
 				for(int i = 0; i < firstList.size(); ++i) {
 					if(i != differIndex)
 						commonTopic.append(firstList.at(i));
 					else
 						commonTopic.append('+');
 
 					if(i != firstList.size() - 1)
 						commonTopic.append('/');
 				}
 			}
 		}
 	}
 
 	//if there is a common topic we return the differIndex
 	if(!commonTopic.isEmpty())
 		return differIndex;
 	else
 		return -1;
 }
 
 /*!
  *\brief Fills the children vector, with the root item's (twSubscriptions) leaf children (meaning no wildcard containing topics)
  *
  * \param children vector of TreeWidgetItem pointers
  * \param root pointer to a TreeWidgetItem of twSubscriptions
  */
 void LiveDataDock::findSubscriptionLeafChildren(QVector<QTreeWidgetItem *>& children, QTreeWidgetItem* root) {
 	if(root->childCount() == 0) {
 		children.push_back(root);
 	} else {
 		for(int i = 0; i < root->childCount(); ++i) {
 			findSubscriptionLeafChildren(children, root->child(i));
 		}
 	}
 }
 
 /*!
  *\brief Returns the amount of topics that the "+" wildcard will replace in the level position
  *
  * \param levelIdx the level currently being investigated
  * \param level the level where the new + wildcard will be placed
  * \param commonList the topic name split into levels
  * \param currentItem pointer to a TreeWidgetItem which represents the parent of the level
  *		  represented by levelIdx
  * \return returns the childCount, or -1 if some topics already represented by + wildcard have different
  *		   amount of children
  */
 int LiveDataDock::checkCommonChildCount(int levelIdx, int level, QStringList& commonList, QTreeWidgetItem* currentItem) {
 	//we recursively check the number of children, until we get to level-1
 	if(levelIdx < level - 1) {
 		if(commonList[levelIdx] != "+") {
 			for(int j = 0; j < currentItem->childCount(); ++j) {
 				if(currentItem->child(j)->text(0) == commonList[levelIdx]) {
 					//if the level isn't represented by + wildcard we simply return the amount of children of the corresponding item, recursively
 					return checkCommonChildCount(levelIdx + 1, level, commonList, currentItem->child(j));
 				}
 			}
 		} else {
 			int childCount = -1;
 			bool ok = true;
 
 			//otherwise we check if every + wildcard represented topic has the same number of children, recursively
 			for(int j = 0; j < currentItem->childCount(); ++j) {
 				int temp = checkCommonChildCount(levelIdx + 1, level, commonList, currentItem->child(j));
 
 				if((j > 0) && (temp != childCount)) {
 					ok = false;
 					break;
 				}
 				childCount = temp;
 			}
 
 			//if yes we return this number, otherwise -1
 			if(ok)
 				return childCount;
 			else
 				return -1;
 		}
 	} else if (levelIdx == level - 1) {
 		if(commonList[levelIdx] != "+") {
 			for(int j = 0; j < currentItem->childCount(); ++j) {
 				if(currentItem->child(j)->text(0) == commonList[levelIdx]) {
 					//if the level isn't represented by + wildcard we simply return the amount of children of the corresponding item
 					return currentItem->child(j)->childCount();
 				}
 			}
 		} else {
 			int childCount = -1;
 			bool ok = true;
 
 			//otherwise we check if every + wildcard represented topic has the same number of children
 			for(int j = 0; j < currentItem->childCount(); ++j) {
 				if((j > 0) && (currentItem->child(j)->childCount() != childCount)) {
 					ok = false;
 					break;
 				}
 				childCount = currentItem->child(j)->childCount();
 			}
 
 			//if yes we return this number, otherwise -1
 			if(ok)
 				return childCount;
 			else
 				return -1;
 		}
 	} else if (level == 1 && levelIdx == 1)
 		return currentItem->childCount();
 
 	return -1;
 }
 
 /*!
  *\brief We search in twSubscriptions for topics that can be represented using + wildcards, then merge them.
  *		 We do this until there are no topics to merge
  */
 void LiveDataDock::manageCommonLevelSubscriptions() {
 	bool foundEqual = false;
 	do{
 		foundEqual = false;
 		QMap<QString, QVector<QString>> equalTopicsMap;
 		QVector<QString> equalTopics;
 
 		//compare the subscriptions present in the TreeWidget
 		for(int i = 0; i < ui.twSubscriptions->topLevelItemCount() - 1; ++i) {
 			for(int j = i + 1; j < ui.twSubscriptions->topLevelItemCount(); ++j) {
 				QString commonTopic = checkCommonLevel(ui.twSubscriptions->topLevelItem(i)->text(0), ui.twSubscriptions->topLevelItem(j)->text(0));
 
 				//if there is a common topic for the 2 compared topics, we add them to the map (using the common topic as key)
 				if(!commonTopic.isEmpty()) {
 					if(!equalTopicsMap[commonTopic].contains(ui.twSubscriptions->topLevelItem(i)->text(0))) {
 						equalTopicsMap[commonTopic].push_back(ui.twSubscriptions->topLevelItem(i)->text(0));
 					}
 
 					if(!equalTopicsMap[commonTopic].contains(ui.twSubscriptions->topLevelItem(j)->text(0))) {
 						equalTopicsMap[commonTopic].push_back(ui.twSubscriptions->topLevelItem(j)->text(0));
 					}
 				}
 			}
 		}
 
 		if(!equalTopicsMap.isEmpty()) {
 			qDebug()<<"Manage equal topics";
 
 			QVector<QString> commonTopics;
 			QMapIterator<QString, QVector<QString>> topics(equalTopicsMap);
 
 			//check for every map entry, if the found topics can be merged or not
 			while(topics.hasNext()) {
 				topics.next();
 
 				int level = commonLevelIndex(topics.value().last(), topics.value().first());
 				QStringList commonList = topics.value().first().split('/', QString::SkipEmptyParts);
 				QTreeWidgetItem* currentItem = nullptr;
 
 				//search the corresponding item to the common topics first level(root)
 				for(int i = 0; i < ui.twTopics->topLevelItemCount(); ++i) {
 					if(ui.twTopics->topLevelItem(i)->text(0) == commonList.first()) {
 						currentItem = ui.twTopics->topLevelItem(i);
 						break;
 					}
 				}
 
 				//calculate the number of topics the new + wildcard could replace
 				int childCount = checkCommonChildCount(1, level, commonList, currentItem);
 				if(childCount > 0) {
 					//if the number of topics found and the calculated number of topics is equal, the topics can be merged
 					if(topics.value().size() == childCount) {
 						qDebug() << "Found common topic to manage: " << topics.key();
 						foundEqual = true;
 						commonTopics.push_back(topics.key());
 					}
 				}
 			}
 
 			if(foundEqual) {
 				//if there are more common topics, the topics of which can be merged, we choose the one which has the lowest level new "+" wildcard
 				int highestLevel = INT_MAX;
 				int topicIdx = -1;
 				for(int i = 0; i < commonTopics.size(); ++i) {
 					int level = commonLevelIndex(equalTopicsMap[commonTopics[i]].first(), commonTopics[i]);
 					if(level < highestLevel) {
 						topicIdx = i;
 						highestLevel = level;
 					}
 				}
 				qDebug() << "Start to manage: " << commonTopics[topicIdx];
 				equalTopics.append(equalTopicsMap[commonTopics[topicIdx]]);
 
 				//Add the common topic ("merging")
 				QString commonTopic;
 				commonTopic = checkCommonLevel(equalTopics.first(), equalTopics.last());
 				QStringList nameList;
 				nameList.append(commonTopic);
 				QTreeWidgetItem* newTopic = new QTreeWidgetItem(nameList);
 				ui.twSubscriptions->addTopLevelItem(newTopic);
 
 				//remove the "merged" topics
 				for(int i = 0; i < equalTopics.size(); ++i) {
 					for(int j = 0; j < ui.twSubscriptions->topLevelItemCount(); ++j){
 						if(ui.twSubscriptions->topLevelItem(j)->text(0) == equalTopics[i]) {
 							newTopic->addChild(ui.twSubscriptions->takeTopLevelItem(j));
 							break;
 						}
 					}
 				}
 
 				//remove any subscription that the new subscription contains
 				for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 					if(checkTopicContains(commonTopic, ui.twSubscriptions->topLevelItem(i)->text(0)) &&
 							commonTopic != ui.twSubscriptions->topLevelItem(i)->text(0) ) {
 						ui.twSubscriptions->topLevelItem(i)->takeChildren();
 						ui.twSubscriptions->takeTopLevelItem(i);
 						i--;
 					}
 				}
 
 				//make the subscription on commonTopic in every MQTTClient from m_mqttClients
-				for (auto* source: m_mqttClients) {
+				for (auto* source : m_mqttClients) {
 					source->addMQTTSubscription(commonTopic, ui.cbQoS->currentIndex());
 				}
 			}
 		}
 	} while(foundEqual);
 }
 
 /*!
  *\brief Adds topicName to twTopics
  *
  * \param topicName the name of the topic, which will be added to the tree widget
  */
 void LiveDataDock::addTopicToTree(const QString &topicName) {
 	QStringList name;
 	QChar sep = '/';
 	QString rootName;
 	if(topicName.contains(sep)) {
 		QStringList list = topicName.split(sep, QString::SkipEmptyParts);
 
 		if(!list.isEmpty()) {
 			rootName = list.at(0);
 			name.append(list.at(0));
 			QTreeWidgetItem* currentItem;
 			//check whether the first level of the topic can be found in twTopics
 			int topItemIdx = -1;
 			for(int i = 0; i < ui.twTopics->topLevelItemCount(); ++i) {
 				if(ui.twTopics->topLevelItem(i)->text(0) == list.at(0)) {
 					topItemIdx = i;
 					break;
 				}
 			}
 			//if not we simply add every level of the topic to the tree
 			if( topItemIdx < 0) {
 				currentItem = new QTreeWidgetItem(name);
 				ui.twTopics->addTopLevelItem(currentItem);
 				for(int i = 1; i < list.size(); ++i) {
 					name.clear();
 					name.append(list.at(i));
 					currentItem->addChild(new QTreeWidgetItem(name));
 					currentItem = currentItem->child(0);
 				}
 			}
 			//otherwise we search for the first level that isn't part of the tree,
 			//then add every level of the topic to the tree from that certain level
 			else {
 				currentItem = ui.twTopics->topLevelItem(topItemIdx);
 				int listIdx = 1;
 				for(; listIdx < list.size(); ++listIdx) {
 					QTreeWidgetItem* childItem = nullptr;
 					bool found = false;
 					for(int j = 0; j < currentItem->childCount(); ++j) {
 						childItem = currentItem->child(j);
 						if(childItem->text(0) == list.at(listIdx)) {
 							found = true;
 							currentItem = childItem;
 							break;
 						}
 					}
 					if(!found) {
 						//this is the level that isn't present in the tree
 						break;
 					}
 				}
 
 				//add every level to the tree starting with the first level that isn't part of the tree
 				for(; listIdx < list.size(); ++listIdx) {
 					name.clear();
 					name.append(list.at(listIdx));
 					currentItem->addChild(new QTreeWidgetItem(name));
 					currentItem = currentItem->child(currentItem->childCount() - 1);
 				}
 			}
 		}
 	}
 	else {
 		rootName = topicName;
 		name.append(topicName);
 		ui.twTopics->addTopLevelItem(new QTreeWidgetItem(name));
 	}
 
 	//if a subscribed topic contains the new topic, we have to update twSubscriptions
 	for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 		QStringList subscriptionName = ui.twSubscriptions->topLevelItem(i)->text(0).split('/', QString::SkipEmptyParts);
 		if (rootName == subscriptionName[0]) {
 			fillSubscriptions();
 			break;
 		}
 	}
 
 	//signals that a newTopic was added, in order to fill the completer of leTopics
 	//we have to pass the whole topic name, not just the root name, for testing purposes
 	emit newTopic(topicName);
 }
 
 /*!
  *\brief called when a client receives a message, if the clients hostname isn't identic with the host name of MQTTClients
  * if the message arrived from a new topic, the topic is put in m_addedTopics
  */
 void LiveDataDock::mqttMessageReceivedInBackground(const QByteArray& message, const QMqttTopicName& topic) {
 	Q_UNUSED(message)
 	if(!m_addedTopics[m_mqttClients.first()->clientHostName()].contains(topic.name())) {
 		m_addedTopics[m_mqttClients.first()->clientHostName()].push_back(topic.name());
 	}
 }
 
 /*!
  *\brief called when an MQTTClient is about to be deleted
  * removes every data connected to the MQTTClient, and disconnects the corresponding client from m_clients
  *
  * \param name the host name of the MQTTClient that will be deleted
  */
 void LiveDataDock::removeClient(const QString& name) {
 	m_clients[name]->disconnectFromHost();
 
 	m_addedTopics.remove(name);
 	m_topicList.remove(name);
 
 	if(m_previousMQTTClient != nullptr && m_previousMQTTClient->clientHostName() == name) {
 		disconnect(m_clients[m_previousMQTTClient->clientHostName()], &QMqttClient::messageReceived, this, &LiveDataDock::mqttMessageReceivedInBackground);
 		m_previousMQTTClient = nullptr;
 	}
 
 	if(m_mqttClients.first()->clientHostName() == name) {
 		ui.twSubscriptions->clear();
 		ui.twTopics->clear();
 		m_mqttClients.clear();
 	}
 
 	delete m_clients[name];
 	m_clients.remove(name);
 }
 
 /*!
  * \brief Used for testing the MQTT related features
  * \param topic
  */
 bool LiveDataDock::testSubscribe(const QString& topic){
 	QStringList topicList = topic.split('/', QString::SkipEmptyParts);
 	QTreeWidgetItem* currentItem = nullptr;
 	for(int i = 0; i <ui.twTopics->topLevelItemCount(); ++i) {
 		if(ui.twTopics->topLevelItem(i)->text(0) == topicList[0]) {
 			currentItem = ui.twTopics->topLevelItem(i);
 			break;
 		}
 	}
 
 	if (currentItem) {
 		for(int i = 1 ; i < topicList.size(); ++i) {
 			if(topicList[i] == '#')
 				break;
 
 			for(int j = 0; j < currentItem->childCount(); ++j) {
 				if(currentItem->child(j)->text(0) == topicList[i]) {
 					currentItem = currentItem->child(j);
 					break;
 				} else if (j == currentItem->childCount() - 1)
 					return false;
 
 			}
 		}
 	} else
 		return false;
 
 	ui.twTopics->setCurrentItem(currentItem);
 	addSubscription();
 	return true;
 }
 
 /*!
  * \brief Used for testing the MQTT related features
  * \param topic
  */
 bool LiveDataDock::testUnsubscribe(const QString& topic) {
 	QTreeWidgetItem* currentItem = nullptr;
 	for(int i = 0; i < ui.twSubscriptions->topLevelItemCount(); ++i) {
 		if(checkTopicContains(ui.twSubscriptions->topLevelItem(i)->text(0), topic)) {
 			currentItem = ui.twSubscriptions->topLevelItem(i);
 			break;
 		}
 	}
 
 	if(currentItem) {
 		do {
 			if(topic == currentItem->text(0)) {
 				ui.twSubscriptions->setCurrentItem(currentItem);
 				removeSubscription();
 				return true;
 			} else {
 				for(int i = 0; i < currentItem->childCount(); ++i) {
 					qDebug()<<currentItem->child(i)->text(0)<<" "<<topic;
 					if(checkTopicContains(currentItem->child(i)->text(0), topic)) {
 						currentItem = currentItem->child(i);
 						break;
 					} else if (i == currentItem->childCount() - 1)
 						return false;
 				}
 			}
 		} while(currentItem);
 	} else
 		return false;
 
 	return false;
 }
 
 void LiveDataDock::showWillSettings() {
 	QMenu menu;
 	const MQTTClient* const fmc = m_mqttClients.at(0);
 	QVector<QString> topics = fmc->topicNames();
 
 	MQTTWillSettingsWidget willSettings(&menu, fmc->willSettings(), topics);
 
 	connect(&willSettings, &MQTTWillSettingsWidget::useChanged, this, &LiveDataDock::useWillMessage);
 	connect(&willSettings, &MQTTWillSettingsWidget::messageTypeChanged, this, &LiveDataDock::willMessageTypeChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::updateTypeChanged, this, &LiveDataDock::willUpdateTypeChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::retainChanged, this, &LiveDataDock::willRetainChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::intervalChanged, this, &LiveDataDock::willUpdateIntervalChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::ownMessageChanged, this, &LiveDataDock::willOwnMessageChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::topicChanged, this, &LiveDataDock::willTopicChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::statisticsChanged, this, &LiveDataDock::statisticsChanged);
 	connect(&willSettings, &MQTTWillSettingsWidget::QoSChanged, this, &LiveDataDock::willQoSChanged);
 	connect(&willSettings, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&willSettings);
 	menu.addAction(widgetAction);
 
 	QPoint pos(ui.bWillSettings->sizeHint().width(),ui.bWillSettings->sizeHint().height());
 	menu.exec(ui.bWillSettings->mapToGlobal(pos));
 }
 #endif
diff --git a/src/kdefrontend/dockwidgets/MatrixDock.cpp b/src/kdefrontend/dockwidgets/MatrixDock.cpp
index 567b93afb..b16d7da09 100644
--- a/src/kdefrontend/dockwidgets/MatrixDock.cpp
+++ b/src/kdefrontend/dockwidgets/MatrixDock.cpp
@@ -1,387 +1,387 @@
 /***************************************************************************
     File                 : MAtrixDock.cpp
     Project              : LabPlot
     Description          : widget for matrix properties
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "MatrixDock.h"
 #include "commonfrontend/matrix/MatrixView.h"
 #include "kdefrontend/TemplateHandler.h"
 
 #include <QDir>
 #include <KConfig>
 #include <KConfigGroup>
 
  /*!
   \class MatrixDock
   \brief Provides a widget for editing the properties of the matrices currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 MatrixDock::MatrixDock(QWidget* parent): QWidget(parent), m_matrix(nullptr), m_initializing(false) {
 	ui.setupUi(this);
 
 	ui.cbFormat->addItem(i18n("Decimal"), QVariant('f'));
 	ui.cbFormat->addItem(i18n("Scientific (e)"), QVariant('e'));
 	ui.cbFormat->addItem(i18n("Scientific (E)"), QVariant('E'));
 	ui.cbFormat->addItem(i18n("Automatic (g)"), QVariant('g'));
 	ui.cbFormat->addItem(i18n("Automatic (G)"), QVariant('G'));
 
 	ui.cbHeader->addItem(i18n("Rows and Columns"));
 	ui.cbHeader->addItem(i18n("xy-Values"));
 	ui.cbHeader->addItem(i18n("Rows, Columns and xy-Values"));
 
 	//Validators
 	ui.leXStart->setValidator( new QDoubleValidator(ui.leXStart) );
 	ui.leXEnd->setValidator( new QDoubleValidator(ui.leXEnd) );
 	ui.leYStart->setValidator( new QDoubleValidator(ui.leYStart) );
 	ui.leYEnd->setValidator( new QDoubleValidator(ui.leYEnd) );
 
 	connect(ui.leName, &QLineEdit::textChanged, this, &MatrixDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &MatrixDock::commentChanged);
 	connect(ui.sbColumnCount, SIGNAL(valueChanged(int)), this, SLOT(columnCountChanged(int)));
 	connect(ui.sbRowCount, SIGNAL(valueChanged(int)), this, SLOT(rowCountChanged(int)));
 	connect(ui.leXStart, SIGNAL(returnPressed()), this, SLOT(xStartChanged()));
 	connect(ui.leXEnd, SIGNAL(returnPressed()), this, SLOT(xEndChanged()));
 	connect(ui.leYStart, SIGNAL(returnPressed()), this, SLOT(yStartChanged()));
 	connect(ui.leYEnd, SIGNAL(returnPressed()), this, SLOT(yEndChanged()));
 	connect(ui.cbFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(numericFormatChanged(int)));
 	connect(ui.sbPrecision, SIGNAL(valueChanged(int)), this, SLOT(precisionChanged(int)));
 	connect(ui.cbHeader, SIGNAL(currentIndexChanged(int)), this, SLOT(headerFormatChanged(int)));
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Matrix);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Matrix);
 	ui.gridLayout->addWidget(templateHandler, 22, 0, 1, 4);
 	templateHandler->show();
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 }
 
 void MatrixDock::setMatrices(QList<Matrix*> list){
 	m_initializing = true;
 	m_matrixList = list;
 	m_matrix = list.first();
 
 	if (list.size()==1){
 		ui.leName->setEnabled(true);
 		ui.leComment->setEnabled(true);
 
 		ui.leName->setText(m_matrix->name());
 		ui.leComment->setText(m_matrix->comment());
 	}else{
 		//disable the fields "Name" and "Comment" if there are more the one matrix
 		ui.leName->setEnabled(false);
 		ui.leComment->setEnabled(false);
 
 		ui.leName->setText("");
 		ui.leComment->setText("");
 	}
 
 	//show the properties of the first Matrix in the list, if there are >1 matrixs
 	this->load();
 
 	// undo functions
 	connect(m_matrix, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(matrixDescriptionChanged(const AbstractAspect*)));
 
 	connect(m_matrix, SIGNAL(rowCountChanged(int)), this, SLOT(matrixRowCountChanged(int)));
 	connect(m_matrix, SIGNAL(columnCountChanged(int)), this, SLOT(matrixColumnCountChanged(int)));
 
 	connect(m_matrix, SIGNAL(xStartChanged(double)), this, SLOT(matrixXStartChanged(double)));
 	connect(m_matrix, SIGNAL(xEndChanged(double)), this, SLOT(matrixXEndChanged(double)));
 	connect(m_matrix, SIGNAL(yStartChanged(double)), this, SLOT(matrixYStartChanged(double)));
 	connect(m_matrix, SIGNAL(yEndChanged(double)), this, SLOT(matrixYEndChanged(double)));
 
 	connect(m_matrix, SIGNAL(numericFormatChanged(char)), this, SLOT(matrixNumericFormatChanged(char)));
 	connect(m_matrix, SIGNAL(precisionChanged(int)), this, SLOT(matrixPrecisionChanged(int)));
 	connect(m_matrix, SIGNAL(headerFormatChanged(Matrix::HeaderFormat)), this, SLOT(matrixHeaderFormatChanged(Matrix::HeaderFormat)));
 
 	m_initializing = false;
 }
 
 //*************************************************************
 //****** SLOTs for changes triggered in MatrixDock *******
 //*************************************************************
 void MatrixDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_matrix->setName(ui.leName->text());
 }
 
 void MatrixDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_matrix->setComment(ui.leComment->text());
 }
 
 
 //mapping to the logical coordinates
 void MatrixDock::xStartChanged() {
 	if (m_initializing)
 		return;
 
 	QString str = ui.leXStart->text().trimmed();
 	if (str.isEmpty()) return;
 	double value = str.toDouble();
 	for (auto* matrix : m_matrixList)
 		matrix->setXStart(value);
 }
 
 void MatrixDock::xEndChanged() {
 	if (m_initializing)
 		return;
 
 	QString str = ui.leXEnd->text().trimmed();
 	if (str.isEmpty()) return;
 	double value = str.toDouble();
 	for (auto* matrix : m_matrixList)
 		matrix->setXEnd(value);
 }
 
 void MatrixDock::yStartChanged() {
 	if (m_initializing)
 		return;
 
 	QString str = ui.leYStart->text().trimmed();
 	if (str.isEmpty()) return;
 	double value = str.toDouble();
 	for (auto* matrix : m_matrixList)
 		matrix->setYStart(value);
 }
 
 void MatrixDock::yEndChanged() {
 	if (m_initializing)
 		return;
 
 	QString str = ui.leYEnd->text().trimmed();
 	if (str.isEmpty()) return;
 	double value = str.toDouble();
 	for (auto* matrix : m_matrixList)
 		matrix->setYEnd(value);
 }
 
 //format
 void MatrixDock::numericFormatChanged(int index) {
 	if (m_initializing)
 		return;
 
 	char format = ui.cbFormat->itemData(index).toChar().toLatin1();
 	for (auto* matrix : m_matrixList)
 		matrix->setNumericFormat(format);
 }
 
 void MatrixDock::precisionChanged(int precision) {
 	if (m_initializing)
 		return;
 
 	for (auto* matrix : m_matrixList)
 		matrix->setPrecision(precision);
 }
 
 void MatrixDock::headerFormatChanged(int value) {
 	if (m_initializing)
 		return;
 
 	auto format = (Matrix::HeaderFormat)value;
 	for (auto* matrix : m_matrixList)
 		matrix->setHeaderFormat(format);
 }
 
 void MatrixDock::rowCountChanged(int rows) {
 	if (m_initializing)
 		return;
 
 	for (auto* matrix : m_matrixList)
 		matrix->setRowCount(rows);
 }
 
 void MatrixDock::columnCountChanged(int columns) {
 	if (m_initializing)
 		return;
 
 	for (auto* matrix : m_matrixList)
 		matrix->setColumnCount(columns);
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in Matrix *********
 //*************************************************************
 void MatrixDock::matrixDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_matrix != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.leComment->text())
 		ui.leComment->setText(aspect->comment());
 
 	m_initializing = false;
 }
 
 //matrix dimensions
 void MatrixDock::matrixRowCountChanged(int count) {
 	m_initializing = true;
 	ui.sbRowCount->setValue(count);
 	m_initializing = false;
 }
 
 void MatrixDock::matrixColumnCountChanged(int count) {
 	m_initializing = true;
 	ui.sbColumnCount->setValue(count);
 	m_initializing = false;
 }
 
 //mapping to the logical coordinates
 void MatrixDock::matrixXStartChanged(double value) {
 	m_initializing = true;
 	ui.leXStart->setText(QString::number(value));
 	m_initializing = false;
 }
 
 void MatrixDock::matrixXEndChanged(double value) {
 	m_initializing = true;
 	ui.leXEnd->setText(QString::number(value));
 	m_initializing = false;
 }
 
 void MatrixDock::matrixYStartChanged(double value) {
 	m_initializing = true;
 	ui.leYStart->setText(QString::number(value));
 	m_initializing = false;
 }
 
 void MatrixDock::matrixYEndChanged(double value) {
 	m_initializing = true;
 	ui.leYEnd->setText(QString::number(value));
 	m_initializing = false;
 }
 
 //format
 void MatrixDock::matrixNumericFormatChanged(char format) {
 	m_initializing = true;
 	int index = ui.cbFormat->findData((int)format);
 	ui.cbFormat->setCurrentIndex(index);
 	m_initializing = false;
 }
 
 void MatrixDock::matrixPrecisionChanged(int precision) {
 	m_initializing = true;
 	ui.sbPrecision->setValue(precision);
 	m_initializing = false;
 }
 
 void MatrixDock::matrixHeaderFormatChanged(Matrix::HeaderFormat format) {
 	m_initializing = true;
 	ui.cbHeader->setCurrentIndex((int)format);
 	m_initializing = false;
 }
 
 //*************************************************************
 //******************** SETTINGS *******************************
 //*************************************************************
 void MatrixDock::load() {
 	//matrix dimensions
 	ui.sbRowCount->setValue(m_matrix->rowCount());
 	ui.sbColumnCount->setValue(m_matrix->columnCount());
 
 	//mapping to the logical coordinates
 	ui.leXStart->setText(QString::number(m_matrix->xStart()));
 	ui.leXEnd->setText(QString::number(m_matrix->xEnd()));
 	ui.leYStart->setText(QString::number(m_matrix->yStart()));
 	ui.leYEnd->setText(QString::number(m_matrix->yEnd()));
 
 	//format
 	ui.cbFormat->setCurrentIndex(ui.cbFormat->findData((int)m_matrix->numericFormat()));
 	ui.sbPrecision->setValue(m_matrix->precision());
 	ui.cbHeader->setCurrentIndex(m_matrix->headerFormat());
 }
 
 void MatrixDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	const int index = config.name().lastIndexOf(QDir::separator());
 	if (index != -1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	const int size = m_matrixList.size();
 	if (size>1)
 		m_matrix->beginMacro(i18n("%1 matrices: template \"%2\" loaded", size, name));
 	else
 		m_matrix->beginMacro(i18n("%1: template \"%2\" loaded", m_matrix->name(), name));
 
 	this->loadConfig(config);
 
 	m_matrix->endMacro();
 }
 
 /*!
 	loads saved matrix properties from \c config.
  */
 void MatrixDock::loadConfig(KConfig& config){
 	KConfigGroup group = config.group("Matrix");
 
 	//matrix dimensions
 	ui.sbRowCount->setValue(group.readEntry("RowCount", m_matrix->rowCount()));
 	ui.sbColumnCount->setValue(group.readEntry("ColumnCount", m_matrix->columnCount()));
 
 	//mapping to the logical coordinates
 	ui.leXStart->setText( QString::number(group.readEntry("XStart", m_matrix->xStart())) );
 	ui.leXEnd->setText( QString::number(group.readEntry("XEnd", m_matrix->xEnd())) );
 	ui.leYStart->setText( QString::number(group.readEntry("YStart", m_matrix->yStart())) );
 	ui.leYEnd->setText( QString::number(group.readEntry("YEnd", m_matrix->yEnd())) );
 
 	//format
 	ui.cbFormat->setCurrentIndex( ui.cbFormat->findData(group.readEntry("NumericFormat", QString(m_matrix->numericFormat()))) );
 	ui.sbPrecision->setValue(group.readEntry("Precision", m_matrix->precision()));
 	ui.cbHeader->setCurrentIndex(group.readEntry("HeaderFormat", (int)m_matrix->headerFormat()));
 }
 
 /*!
 	saves matrix properties to \c config.
  */
 void MatrixDock::saveConfigAsTemplate(KConfig& config){
 	KConfigGroup group = config.group("Matrix");
 
 	//matrix dimensions
 	group.writeEntry("RowCount", ui.sbRowCount->value());
 	group.writeEntry("ColumnCount", ui.sbColumnCount->value());
 
 	//mapping to the logical coordinates
 	group.writeEntry("XStart", ui.leXStart->text().toInt());
 	group.writeEntry("XEnd", ui.leXEnd->text().toInt());
 	group.writeEntry("YStart", ui.leYStart->text().toInt());
 	group.writeEntry("YEnd", ui.leYEnd->text().toInt());
 
 	//format
 	group.writeEntry("NumericFormat", ui.cbFormat->itemData(ui.cbFormat->currentIndex()));
 	group.writeEntry("Precision", ui.sbPrecision->value());
 	group.writeEntry("HeaderFormat", ui.cbHeader->currentIndex());
 
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/NoteDock.cpp b/src/kdefrontend/dockwidgets/NoteDock.cpp
index 318606413..77ced4999 100644
--- a/src/kdefrontend/dockwidgets/NoteDock.cpp
+++ b/src/kdefrontend/dockwidgets/NoteDock.cpp
@@ -1,129 +1,129 @@
 /***************************************************************************
     File                 : NotesDock.cpp
     Project              : LabPlot
     Description          : Dock for configuring notes
     --------------------------------------------------------------------
     Copyright            : (C) 2016 Garvit Khatri (garvitdelhi@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 "NoteDock.h"
 #include "kdefrontend/TemplateHandler.h"
 
 #include <QDir>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 NoteDock::NoteDock(QWidget *parent) : QWidget(parent), m_initializing(false), m_notes(nullptr) {
 	ui.setupUi(this);
 
 	connect(ui.leName, &QLineEdit::textChanged, this, [this]() { nameChanged(ui.leName->text()); });
 	connect(ui.leComment, &QLineEdit::textChanged, this, [this]() { commentChanged(ui.leComment->text()); });
 
 	connect(ui.kcbBgColor, &KColorButton::changed, this, &NoteDock::backgroundColorChanged);
 	connect(ui.kcbTextColor, &KColorButton::changed, this, &NoteDock::textColorChanged);
 	connect(ui.kfrTextFont, &KFontRequester::fontSelected, this, &NoteDock::textFontChanged);
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Worksheet);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Worksheet);
 	ui.gridLayout->addWidget(templateHandler, 8, 3);
 	templateHandler->show();
 	connect(templateHandler, &TemplateHandler::loadConfigRequested, this, &NoteDock::loadConfigFromTemplate);
 	connect(templateHandler, &TemplateHandler::saveConfigRequested, this, &NoteDock::saveConfigAsTemplate);
 }
 
 void NoteDock::setNotesList(QList< Note* > list) {
 	m_notesList = list;
 	m_notes = list.first();
 
 	m_initializing=true;
 	ui.leName->setText(m_notes->name());
 	ui.kcbBgColor->setColor(m_notes->backgroundColor());
 	ui.kcbTextColor->setColor(m_notes->textColor());
 	ui.kfrTextFont->setFont(m_notes->textFont());
 	m_initializing=false;
 }
 
 //*************************************************************
 //********** SLOTs for changes triggered in NoteDock **********
 //*************************************************************
 void NoteDock::nameChanged(const QString& name) {
 	if (m_initializing)
 		return;
 
 	m_notes->setName(name);
 }
 
 void NoteDock::commentChanged(const QString& name) {
 	if (m_initializing)
 		return;
 
 	m_notes->setComment(name);
 }
 
 void NoteDock::backgroundColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	for (auto* note : m_notesList)
 		note->setBackgroundColor(color);
 }
 
 void NoteDock::textColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	for (auto* note : m_notesList)
 		note->setTextColor(color);
 }
 
 void NoteDock::textFontChanged(const QFont& font) {
 	if (m_initializing)
 		return;
 
 	for (auto* note : m_notesList)
 		note->setTextFont(font);
 }
 
 //*************************************************************
 //************************* Settings **************************
 //*************************************************************
 void NoteDock::loadConfigFromTemplate(KConfig& config) {
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index!=-1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	KConfigGroup group = config.group("Notes");
 	ui.kcbBgColor->setColor(group.readEntry("BackgroundColor", m_notes->backgroundColor()));
 	ui.kcbTextColor->setColor(group.readEntry("TextColor", m_notes->textColor()));
 	ui.kfrTextFont->setFont(group.readEntry("TextColor", m_notes->textFont()));
 }
 
 void NoteDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group("Notes");
 
 	group.writeEntry("BackgroundColor", ui.kcbBgColor->color());
 	group.writeEntry("TextColor", ui.kcbTextColor->color());
 	group.writeEntry("TextFont", ui.kfrTextFont->font());
 }
diff --git a/src/kdefrontend/dockwidgets/ProjectDock.cpp b/src/kdefrontend/dockwidgets/ProjectDock.cpp
index 0dffaa008..38c385171 100644
--- a/src/kdefrontend/dockwidgets/ProjectDock.cpp
+++ b/src/kdefrontend/dockwidgets/ProjectDock.cpp
@@ -1,136 +1,136 @@
 /***************************************************************************
     File                 : ProjectDock.cpp
     Project              : LabPlot
     Description          : widget for project properties
     --------------------------------------------------------------------
     Copyright            : (C) 2012-2013 by Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 	Copyright            : (C) 2013 Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "ProjectDock.h"
 #include "backend/core/Project.h"
 #include "kdefrontend/TemplateHandler.h"
 #include <KConfigGroup>
 
 /*!
   \class ProjectDock
   \brief Provides a widget for editing the properties of a project
 
   \ingroup kdefrontend
 */
 
 ProjectDock::ProjectDock(QWidget *parent): QWidget(parent),	m_project(nullptr), m_initializing(false) {
 	ui.setupUi(this);
 
 	// SLOTS
 	connect(ui.leName, &QLineEdit::textChanged, this, &ProjectDock::titleChanged);
 	connect(ui.leAuthor, &QLineEdit::textChanged, this, &ProjectDock::authorChanged);
 	connect(ui.tbComment, &QTextBrowser::textChanged, this, &ProjectDock::commentChanged);
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Worksheet);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Worksheet);
 	ui.verticalLayout->addWidget(templateHandler, 0, nullptr);
 	templateHandler->show();
 	connect(templateHandler, &TemplateHandler::loadConfigRequested, this, &ProjectDock::loadConfig);
 	connect(templateHandler, &TemplateHandler::saveConfigRequested, this, &ProjectDock::saveConfig);
 
 	this->retranslateUi();
 }
 
 void ProjectDock::setProject(Project *project) {
 	m_initializing=true;
 	m_project = project;
 	ui.leFileName->setText(project->fileName());
 	ui.lVersion->setText(project->version());
 	ui.lCreated->setText(project->creationTime().toString());
 	ui.lModified->setText(project->modificationTime().toString());
 
 	//show default properties of the project
 	KConfig config("", KConfig::SimpleConfig);
 	loadConfig(config);
 
 	connect(m_project, &Project::aspectDescriptionChanged, this, &ProjectDock::projectDescriptionChanged);
 
 	m_initializing = false;
 }
 
 //************************************************************
 //****************** SLOTS ********************************
 //************************************************************
 void ProjectDock::retranslateUi(){
 }
 
 void ProjectDock::titleChanged(const QString& title){
 	if (m_initializing)
 		return;
 
 	m_project->setName(title);
 }
 
 void ProjectDock::authorChanged(const QString& author){
 	if (m_initializing)
 		return;
 
 	m_project->setAuthor(author);
 }
 
 void ProjectDock::commentChanged(){
 	if (m_initializing)
 		return;
 
 	m_project->setComment(ui.tbComment->toPlainText());
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in Project   ***********
 //*************************************************************
 void ProjectDock::projectDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_project != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 			ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.tbComment->toPlainText())
 			ui.tbComment->setText(aspect->comment());
 
 	m_initializing = false;
 }
 
 //*************************************************************
 //************************* Settings **************************
 //*************************************************************
 void ProjectDock::loadConfig(KConfig& config){
 	KConfigGroup group = config.group( "Project" );
 
 	ui.leName->setText( group.readEntry("Name", m_project->name()) );
 	ui.leAuthor->setText( group.readEntry("Author", m_project->author()) );
 	ui.tbComment->setText( group.readEntry("Comment", m_project->comment()) );
 }
 
 void ProjectDock::saveConfig(KConfig& config){
 	KConfigGroup group = config.group( "Project" );
 
 	group.writeEntry("Name", ui.leName->text());
 	group.writeEntry("Author", ui.leAuthor->text());
 	group.writeEntry("Comment", ui.tbComment->toPlainText());
 }
diff --git a/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp b/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
index 388a52104..a02856121 100644
--- a/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
+++ b/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
@@ -1,229 +1,229 @@
 /***************************************************************************
     File                 : SpreadsheetDock.cpp
     Project              : LabPlot
     Description          : widget for spreadsheet properties
     --------------------------------------------------------------------
     Copyright            : (C) 2010-2015 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2012-2013 by Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "SpreadsheetDock.h"
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "kdefrontend/TemplateHandler.h"
 #include <QDir>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
  /*!
   \class SpreadsheetDock
   \brief Provides a widget for editing the properties of the spreadsheets currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 
 SpreadsheetDock::SpreadsheetDock(QWidget* parent): QWidget(parent), m_spreadsheet(nullptr), m_initializing(false) {
 	ui.setupUi(this);
 
 	connect(ui.leName, &QLineEdit::textChanged, this, &SpreadsheetDock::nameChanged);
 	connect(ui.teComment, &QTextEdit::textChanged, this, &SpreadsheetDock::commentChanged);
 	connect(ui.sbColumnCount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &SpreadsheetDock::columnCountChanged);
 	connect(ui.sbRowCount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &SpreadsheetDock::rowCountChanged);
 	connect(ui.cbShowComments, &QCheckBox::stateChanged, this, &SpreadsheetDock::commentsShownChanged);
 
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::Spreadsheet);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Spreadsheet);
 	ui.gridLayout->addWidget(templateHandler, 11, 0, 1, 4);
 	templateHandler->show();
 	connect(templateHandler, &TemplateHandler::loadConfigRequested, this, &SpreadsheetDock::loadConfigFromTemplate);
 	connect(templateHandler, &TemplateHandler::saveConfigRequested, this, &SpreadsheetDock::saveConfigAsTemplate);
 	connect(templateHandler, &TemplateHandler::info, this, &SpreadsheetDock::info);
 }
 
 /*!
 	set the current spreadsheet(s)
 */
 void SpreadsheetDock::setSpreadsheets(QList<Spreadsheet*> list) {
 	m_initializing = true;
 	m_spreadsheetList = list;
 	m_spreadsheet = list.first();
 
 	if (list.size() == 1) {
 		ui.leName->setEnabled(true);
 		ui.teComment->setEnabled(true);
 
 		ui.leName->setText(m_spreadsheet->name());
 		ui.teComment->setText(m_spreadsheet->comment());
 	} else {
 		//disable the fields "Name" and "Comment" if there are more then one spreadsheet
 		ui.leName->setEnabled(false);
 		ui.teComment->setEnabled(false);
 
 		ui.leName->setText("");
 		ui.teComment->setText("");
   	}
 
 	//show the properties of the first Spreadsheet in the list
 	this->load();
 
 	// undo functions
 	connect(m_spreadsheet, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),
 			this, SLOT(spreadsheetDescriptionChanged(const AbstractAspect*)));
 	connect(m_spreadsheet, SIGNAL(rowCountChanged(int)),this, SLOT(spreadsheetRowCountChanged(int)));
 	connect(m_spreadsheet, SIGNAL(columnCountChanged(int)),this, SLOT(spreadsheetColumnCountChanged(int)));
 	//TODO: show comments
 
 	m_initializing = false;
 }
 
 //*************************************************************
 //****** SLOTs for changes triggered in SpreadsheetDock *******
 //*************************************************************
 void SpreadsheetDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_spreadsheet->setName(ui.leName->text());
 }
 
 void SpreadsheetDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_spreadsheet->setComment(ui.teComment->document()->toPlainText());
 }
 
 void SpreadsheetDock::rowCountChanged(int rows) {
 	if (m_initializing)
 		return;
 
-	for (auto* spreadsheet: m_spreadsheetList)
+	for (auto* spreadsheet : m_spreadsheetList)
 		spreadsheet->setRowCount(rows);
 }
 
 void SpreadsheetDock::columnCountChanged(int columns) {
 	if (m_initializing)
 		return;
 
-	for (auto* spreadsheet: m_spreadsheetList)
+	for (auto* spreadsheet : m_spreadsheetList)
 		spreadsheet->setColumnCount(columns);
 }
 
 /*!
   switches on/off  the comment header in the views of the selected spreadsheets.
 */
 void SpreadsheetDock::commentsShownChanged(int state) {
 	if (m_initializing)
 		return;
 
-	for (auto* spreadsheet: m_spreadsheetList)
+	for (auto* spreadsheet : m_spreadsheetList)
 		qobject_cast<SpreadsheetView*>(spreadsheet->view())->showComments(state);
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in Spreadsheet *********
 //*************************************************************
 void SpreadsheetDock::spreadsheetDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_spreadsheet != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.teComment->toPlainText())
 		ui.teComment->document()->setPlainText(aspect->comment());
 
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetRowCountChanged(int count) {
 	m_initializing = true;
   	ui.sbRowCount->setValue(count);
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetColumnCountChanged(int count) {
 	m_initializing = true;
   	ui.sbColumnCount->setValue(count);
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetShowCommentsChanged(int checked) {
 	m_initializing = true;
 	ui.cbShowComments->setChecked(checked);
 	m_initializing = false;
 }
 
 //*************************************************************
 //******************** SETTINGS *******************************
 //*************************************************************
 void SpreadsheetDock::load() {
 	ui.sbColumnCount->setValue(m_spreadsheet->columnCount());
 	ui.sbRowCount->setValue(m_spreadsheet->rowCount());
 
-	auto view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
+	auto* view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
 	ui.cbShowComments->setChecked(view->areCommentsShown());
 }
 
 void SpreadsheetDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	const int index = config.name().lastIndexOf(QDir::separator());
 	if (index != -1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	const int size = m_spreadsheetList.size();
 	if (size > 1)
 		m_spreadsheet->beginMacro(i18n("%1 spreadsheets: template \"%2\" loaded", size, name));
 	else
 		m_spreadsheet->beginMacro(i18n("%1: template \"%2\" loaded", m_spreadsheet->name(), name));
 
 	this->loadConfig(config);
 
 	m_spreadsheet->endMacro();
 }
 
 /*!
 	loads saved spreadsheet properties from \c config.
  */
 void SpreadsheetDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group( "Spreadsheet" );
 
 	ui.sbColumnCount->setValue(group.readEntry("ColumnCount", m_spreadsheet->columnCount()));
 	ui.sbRowCount->setValue(group.readEntry("RowCount", m_spreadsheet->rowCount()));
 
-	auto view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
+	auto* view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
 	ui.cbShowComments->setChecked(group.readEntry("ShowComments", view->areCommentsShown()));
 }
 
 /*!
 	saves spreadsheet properties to \c config.
  */
 void SpreadsheetDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "Spreadsheet" );
 	group.writeEntry("ColumnCount", ui.sbColumnCount->value());
 	group.writeEntry("RowCount", ui.sbRowCount->value());
 	group.writeEntry("ShowComments",ui.cbShowComments->isChecked());
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/XYCurveDock.cpp b/src/kdefrontend/dockwidgets/XYCurveDock.cpp
index 81d724ad3..3bf8d95c4 100644
--- a/src/kdefrontend/dockwidgets/XYCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYCurveDock.cpp
@@ -1,2254 +1,2254 @@
 /***************************************************************************
     File                 : XYCurveDock.cpp
     Project              : LabPlot
     Description          : widget for XYCurve properties
     --------------------------------------------------------------------
     Copyright            : (C) 2010-2018 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2012-2017 Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYCurveDock.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/TemplateHandler.h"
 #include "kdefrontend/GuiTools.h"
 
 #include <QCompleter>
 #include <QDir>
 #include <QDirModel>
 #include <QFileDialog>
 #include <QImageReader>
 #include <QPainter>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 /*!
   \class XYCurveDock
   \brief  Provides a widget for editing the properties of the XYCurves (2D-curves) currently selected in the project explorer.
 
   If more than one curves are set, the properties of the first column are shown. The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYCurveDock::XYCurveDock(QWidget* parent) : QWidget(parent),
 	cbXColumn(nullptr),
 	cbYColumn(nullptr),
 	m_curve(nullptr),
 	m_aspectTreeModel(nullptr) {
 
 	ui.setupUi(this);
 
 	//Tab "Values"
-	auto gridLayout = qobject_cast<QGridLayout*>(ui.tabValues->layout());
+	auto* gridLayout = qobject_cast<QGridLayout*>(ui.tabValues->layout());
 	cbValuesColumn = new TreeViewComboBox(ui.tabValues);
 	gridLayout->addWidget(cbValuesColumn, 2, 2, 1, 1);
 
 	//Tab "Filling"
 	ui.cbFillingColorStyle->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
 	ui.bFillingOpen->setIcon( QIcon::fromTheme("document-open") );
 
-	auto completer = new QCompleter(this);
+	auto* completer = new QCompleter(this);
 	completer->setModel(new QDirModel);
 	ui.leFillingFileName->setCompleter(completer);
 
 	//Tab "Error bars"
 	gridLayout = qobject_cast<QGridLayout*>(ui.tabErrorBars->layout());
 
 	cbXErrorPlusColumn = new TreeViewComboBox(ui.tabErrorBars);
 	gridLayout->addWidget(cbXErrorPlusColumn, 2, 2, 1, 1);
 
 	cbXErrorMinusColumn = new TreeViewComboBox(ui.tabErrorBars);
 	gridLayout->addWidget(cbXErrorMinusColumn, 3, 2, 1, 1);
 
 	cbYErrorPlusColumn = new TreeViewComboBox(ui.tabErrorBars);
 	gridLayout->addWidget(cbYErrorPlusColumn, 7, 2, 1, 1);
 
 	cbYErrorMinusColumn = new TreeViewComboBox(ui.tabErrorBars);
 	gridLayout->addWidget(cbYErrorMinusColumn, 8, 2, 1, 1);
 
 	//adjust layouts in the tabs
 	for (int i = 0; i < ui.tabWidget->count(); ++i) {
-		auto layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
+		auto* layout = dynamic_cast<QGridLayout*>(ui.tabWidget->widget(i)->layout());
 		if (!layout)
 			continue;
 
 		layout->setContentsMargins(2,2,2,2);
 		layout->setHorizontalSpacing(2);
 		layout->setVerticalSpacing(2);
 	}
 
 	//Slots
 
 	//Lines
 	connect( ui.cbLineType, SIGNAL(currentIndexChanged(int)), this, SLOT(lineTypeChanged(int)) );
 	connect( ui.sbLineInterpolationPointsCount, SIGNAL(valueChanged(int)), this, SLOT(lineInterpolationPointsCountChanged(int)) );
 	connect( ui.chkLineSkipGaps, SIGNAL(clicked(bool)), this, SLOT(lineSkipGapsChanged(bool)) );
 	connect( ui.chkLineIncreasingXOnly, &QCheckBox::clicked, this, &XYCurveDock::lineIncreasingXOnlyChanged );
 	connect( ui.cbLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(lineStyleChanged(int)) );
 	connect( ui.kcbLineColor, SIGNAL(changed(QColor)), this, SLOT(lineColorChanged(QColor)) );
 	connect( ui.sbLineWidth, SIGNAL(valueChanged(double)), this, SLOT(lineWidthChanged(double)) );
 	connect( ui.sbLineOpacity, SIGNAL(valueChanged(int)), this, SLOT(lineOpacityChanged(int)) );
 
 	connect( ui.cbDropLineType, SIGNAL(currentIndexChanged(int)), this, SLOT(dropLineTypeChanged(int)) );
 	connect( ui.cbDropLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(dropLineStyleChanged(int)) );
 	connect( ui.kcbDropLineColor, SIGNAL(changed(QColor)), this, SLOT(dropLineColorChanged(QColor)) );
 	connect( ui.sbDropLineWidth, SIGNAL(valueChanged(double)), this, SLOT(dropLineWidthChanged(double)) );
 	connect( ui.sbDropLineOpacity, SIGNAL(valueChanged(int)), this, SLOT(dropLineOpacityChanged(int)) );
 
 	//Symbol
 	connect( ui.cbSymbolStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsStyleChanged(int)) );
 	connect( ui.sbSymbolSize, SIGNAL(valueChanged(double)), this, SLOT(symbolsSizeChanged(double)) );
 	connect( ui.sbSymbolRotation, SIGNAL(valueChanged(int)), this, SLOT(symbolsRotationChanged(int)) );
 	connect( ui.sbSymbolOpacity, SIGNAL(valueChanged(int)), this, SLOT(symbolsOpacityChanged(int)) );
 
 	connect( ui.cbSymbolFillingStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsFillingStyleChanged(int)) );
 	connect( ui.kcbSymbolFillingColor, SIGNAL(changed(QColor)), this, SLOT(symbolsFillingColorChanged(QColor)) );
 
 	connect( ui.cbSymbolBorderStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(symbolsBorderStyleChanged(int)) );
 	connect( ui.kcbSymbolBorderColor, SIGNAL(changed(QColor)), this, SLOT(symbolsBorderColorChanged(QColor)) );
 	connect( ui.sbSymbolBorderWidth, SIGNAL(valueChanged(double)), this, SLOT(symbolsBorderWidthChanged(double)) );
 
 	//Values
 	connect( ui.cbValuesType, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesTypeChanged(int)) );
 	connect( cbValuesColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(valuesColumnChanged(QModelIndex)) );
 	connect( ui.cbValuesPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesPositionChanged(int)) );
 	connect( ui.sbValuesDistance, SIGNAL(valueChanged(double)), this, SLOT(valuesDistanceChanged(double)) );
 	connect( ui.sbValuesRotation, SIGNAL(valueChanged(int)), this, SLOT(valuesRotationChanged(int)) );
 	connect( ui.sbValuesOpacity, SIGNAL(valueChanged(int)), this, SLOT(valuesOpacityChanged(int)) );
 
 	//TODO connect( ui.cbValuesFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(valuesColumnFormatChanged(int)) );
 	connect( ui.leValuesPrefix, SIGNAL(returnPressed()), this, SLOT(valuesPrefixChanged()) );
 	connect( ui.leValuesSuffix, SIGNAL(returnPressed()), this, SLOT(valuesSuffixChanged()) );
 	connect( ui.kfrValuesFont, SIGNAL(fontSelected(QFont)), this, SLOT(valuesFontChanged(QFont)) );
 	connect( ui.kcbValuesColor, SIGNAL(changed(QColor)), this, SLOT(valuesColorChanged(QColor)) );
 
 	//Filling
 	connect( ui.cbFillingPosition, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingPositionChanged(int)) );
 	connect( ui.cbFillingType, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingTypeChanged(int)) );
 	connect( ui.cbFillingColorStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingColorStyleChanged(int)) );
 	connect( ui.cbFillingImageStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingImageStyleChanged(int)) );
 	connect( ui.cbFillingBrushStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(fillingBrushStyleChanged(int)) );
 	connect(ui.bFillingOpen, SIGNAL(clicked(bool)), this, SLOT(selectFile()));
 	connect( ui.leFillingFileName, SIGNAL(returnPressed()), this, SLOT(fileNameChanged()) );
 	connect( ui.leFillingFileName, SIGNAL(textChanged(QString)), this, SLOT(fileNameChanged()) );
 	connect( ui.kcbFillingFirstColor, SIGNAL(changed(QColor)), this, SLOT(fillingFirstColorChanged(QColor)) );
 	connect( ui.kcbFillingSecondColor, SIGNAL(changed(QColor)), this, SLOT(fillingSecondColorChanged(QColor)) );
 	connect( ui.sbFillingOpacity, SIGNAL(valueChanged(int)), this, SLOT(fillingOpacityChanged(int)) );
 
 	//Error bars
 	connect( ui.cbXErrorType, SIGNAL(currentIndexChanged(int)), this, SLOT(xErrorTypeChanged(int)) );
 	connect( cbXErrorPlusColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xErrorPlusColumnChanged(QModelIndex)) );
 	connect( cbXErrorMinusColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xErrorMinusColumnChanged(QModelIndex)) );
 	connect( ui.cbYErrorType, SIGNAL(currentIndexChanged(int)), this, SLOT(yErrorTypeChanged(int)) );
 	connect( cbYErrorPlusColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yErrorPlusColumnChanged(QModelIndex)) );
 	connect( cbYErrorMinusColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yErrorMinusColumnChanged(QModelIndex)) );
 	connect( ui.cbErrorBarsType, SIGNAL(currentIndexChanged(int)), this, SLOT(errorBarsTypeChanged(int)) );
 	connect( ui.sbErrorBarsCapSize, SIGNAL(valueChanged(double)), this, SLOT(errorBarsCapSizeChanged(double)) );
 	connect( ui.cbErrorBarsStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(errorBarsStyleChanged(int)) );
 	connect( ui.kcbErrorBarsColor, SIGNAL(changed(QColor)), this, SLOT(errorBarsColorChanged(QColor)) );
 	connect( ui.sbErrorBarsWidth, SIGNAL(valueChanged(double)), this, SLOT(errorBarsWidthChanged(double)) );
 	connect( ui.sbErrorBarsOpacity, SIGNAL(valueChanged(int)), this, SLOT(errorBarsOpacityChanged(int)) );
 
 	//template handler
-	auto templateHandler = new TemplateHandler(this, TemplateHandler::XYCurve);
+	auto* templateHandler = new TemplateHandler(this, TemplateHandler::XYCurve);
 	ui.verticalLayout->addWidget(templateHandler);
 	templateHandler->show();
 	connect(templateHandler, SIGNAL(loadConfigRequested(KConfig&)), this, SLOT(loadConfigFromTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(saveConfigRequested(KConfig&)), this, SLOT(saveConfigAsTemplate(KConfig&)));
 	connect(templateHandler, SIGNAL(info(QString)), this, SIGNAL(info(QString)));
 
 	retranslateUi();
 	init();
 }
 
 XYCurveDock::~XYCurveDock() {
 	if (m_aspectTreeModel)
 		delete m_aspectTreeModel;
 }
 
 void XYCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	// Tab "General"
-	auto gridLayout = qobject_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = qobject_cast<QGridLayout*>(generalTab->layout());
 
 	cbXColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXColumn, 2, 2, 1, 1);
 
 	cbYColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYColumn, 3, 2, 1, 1);
 
 	//General
 	connect(uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYCurveDock::nameChanged);
 	connect(uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYCurveDock::commentChanged);
 	connect(uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)));
 	connect(cbXColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xColumnChanged(QModelIndex)));
 	connect(cbYColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yColumnChanged(QModelIndex)));
 }
 
 void XYCurveDock::init() {
 	m_initializing = true;
 
 	//Line
 	ui.cbLineType->addItem(i18n("None"));
 	ui.cbLineType->addItem(i18n("Line"));
 	ui.cbLineType->addItem(i18n("Horiz. Start"));
 	ui.cbLineType->addItem(i18n("Vert. Start"));
 	ui.cbLineType->addItem(i18n("Horiz. Midpoint"));
 	ui.cbLineType->addItem(i18n("Vert. Midpoint"));
 	ui.cbLineType->addItem(i18n("2-segments"));
 	ui.cbLineType->addItem(i18n("3-segments"));
 	ui.cbLineType->addItem(i18n("Cubic Spline (Natural)"));
 	ui.cbLineType->addItem(i18n("Cubic Spline (Periodic)"));
 	ui.cbLineType->addItem(i18n("Akima-spline (Natural)"));
 	ui.cbLineType->addItem(i18n("Akima-spline (Periodic)"));
 
 	QPainter pa;
 	//TODO size of the icon depending on the actual height of the combobox?
 	int iconSize = 20;
 	QPixmap pm(iconSize, iconSize);
 	ui.cbLineType->setIconSize(QSize(iconSize, iconSize));
 
 	QPen pen(Qt::SolidPattern, 0);
 	const QColor& color = (palette().color(QPalette::Base).lightness() < 128) ? Qt::white : Qt::black;
 	pen.setColor(color);
 	pa.setPen( pen );
 
 	//no line
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.end();
 	ui.cbLineType->setItemIcon(0, pm);
 
 	//line
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(1, pm);
 
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,17,3);
 	pa.drawLine(17,3,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(2, pm);
 
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,3,17);
 	pa.drawLine(3,17,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(3, pm);
 
 	//horizontal midpoint
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,10,3);
 	pa.drawLine(10,3,10,17);
 	pa.drawLine(10,17,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(4, pm);
 
 	//vertical midpoint
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,3,10);
 	pa.drawLine(3,10,17,10);
 	pa.drawLine(17,10,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(5, pm);
 
 	//2-segments
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 8,8,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,10,10);
 	pa.end();
 	ui.cbLineType->setItemIcon(6, pm);
 
 	//3-segments
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 8,8,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.drawLine(3,3,17,17);
 	pa.end();
 	ui.cbLineType->setItemIcon(7, pm);
 
 	//natural spline
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setPen(pen);
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawEllipse( 1,1,4,4);
 	pa.drawEllipse( 15,15,4,4);
 	pa.rotate(45);
 	pa.drawArc(2*sqrt(2),-4,17*sqrt(2),20,30*16,120*16);
 
 	pa.end();
 	ui.cbLineType->setItemIcon(8, pm);
 	ui.cbLineType->setItemIcon(9, pm);
 	ui.cbLineType->setItemIcon(10, pm);
 	ui.cbLineType->setItemIcon(11, pm);
 
 	GuiTools::updatePenStyles(ui.cbLineStyle, Qt::black);
 
 	//Drop lines
 	ui.cbDropLineType->addItem(i18n("No Drop Lines"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, X"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, Y"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, XY"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, X, Zero Baseline"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, X, Min Baseline"));
 	ui.cbDropLineType->addItem(i18n("Drop Lines, X, Max Baseline"));
 	GuiTools::updatePenStyles(ui.cbDropLineStyle, Qt::black);
 
 	//Symbols
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, Qt::black);
 
 	ui.cbSymbolStyle->setIconSize(QSize(iconSize, iconSize));
 	QTransform trafo;
 	trafo.scale(15, 15);
 
 	ui.cbSymbolStyle->addItem(i18n("None"));
 	for (int i = 1; i < 19; ++i) {	//TODO: use enum count
 		const auto style = (Symbol::Style)i;
 		pm.fill(Qt::transparent);
 		pa.begin(&pm);
 		pa.setPen(pen);
 		pa.setRenderHint(QPainter::Antialiasing);
 		pa.translate(iconSize/2,iconSize/2);
 		pa.drawPath(trafo.map(Symbol::pathFromStyle(style)));
 		pa.end();
 		ui.cbSymbolStyle->addItem(QIcon(pm), Symbol::nameFromStyle(style));
 	}
 
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, Qt::black);
 	m_initializing = false;
 
 	//Values
 	ui.cbValuesType->addItem(i18n("No Values"));
 	ui.cbValuesType->addItem("x");
 	ui.cbValuesType->addItem("y");
 	ui.cbValuesType->addItem("x, y");
 	ui.cbValuesType->addItem("(x, y)");
 	ui.cbValuesType->addItem(i18n("Custom Column"));
 
 	ui.cbValuesPosition->addItem(i18n("Above"));
 	ui.cbValuesPosition->addItem(i18n("Below"));
 	ui.cbValuesPosition->addItem(i18n("Left"));
 	ui.cbValuesPosition->addItem(i18n("Right"));
 
 	//Filling
 	ui.cbFillingPosition->clear();
 	ui.cbFillingPosition->addItem(i18n("None"));
 	ui.cbFillingPosition->addItem(i18n("Above"));
 	ui.cbFillingPosition->addItem(i18n("Below"));
 	ui.cbFillingPosition->addItem(i18n("Zero Baseline"));
 	ui.cbFillingPosition->addItem(i18n("Left"));
 	ui.cbFillingPosition->addItem(i18n("Right"));
 
 	ui.cbFillingType->clear();
 	ui.cbFillingType->addItem(i18n("Color"));
 	ui.cbFillingType->addItem(i18n("Image"));
 	ui.cbFillingType->addItem(i18n("Pattern"));
 
 	ui.cbFillingColorStyle->clear();
 	ui.cbFillingColorStyle->addItem(i18n("Single Color"));
 	ui.cbFillingColorStyle->addItem(i18n("Horizontal Gradient"));
 	ui.cbFillingColorStyle->addItem(i18n("Vertical Gradient"));
 	ui.cbFillingColorStyle->addItem(i18n("Diag. Gradient (From Top Left)"));
 	ui.cbFillingColorStyle->addItem(i18n("Diag. Gradient (From Bottom Left)"));
 	ui.cbFillingColorStyle->addItem(i18n("Radial Gradient"));
 
 	ui.cbFillingImageStyle->clear();
 	ui.cbFillingImageStyle->addItem(i18n("Scaled and Cropped"));
 	ui.cbFillingImageStyle->addItem(i18n("Scaled"));
 	ui.cbFillingImageStyle->addItem(i18n("Scaled, Keep Proportions"));
 	ui.cbFillingImageStyle->addItem(i18n("Centered"));
 	ui.cbFillingImageStyle->addItem(i18n("Tiled"));
 	ui.cbFillingImageStyle->addItem(i18n("Center Tiled"));
 	GuiTools::updateBrushStyles(ui.cbFillingBrushStyle, Qt::SolidPattern);
 
 	//Error-bars
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.drawLine(3,10,17,10);//vert. line
 	pa.drawLine(10,3,10,17);//hor. line
 	pa.end();
 	ui.cbErrorBarsType->addItem(i18n("Bars"));
 	ui.cbErrorBarsType->setItemIcon(0, pm);
 
 	pm.fill(Qt::transparent);
 	pa.begin( &pm );
 	pa.setRenderHint(QPainter::Antialiasing);
 	pa.setBrush(Qt::SolidPattern);
 	pa.drawLine(3,10,17,10); //vert. line
 	pa.drawLine(10,3,10,17); //hor. line
 	pa.drawLine(7,3,13,3); //upper cap
 	pa.drawLine(7,17,13,17); //bottom cap
 	pa.drawLine(3,7,3,13); //left cap
 	pa.drawLine(17,7,17,13); //right cap
 	pa.end();
 	ui.cbErrorBarsType->addItem(i18n("Bars with Ends"));
 	ui.cbErrorBarsType->setItemIcon(1, pm);
 
 	ui.cbXErrorType->addItem(i18n("No"));
 	ui.cbXErrorType->addItem(i18n("Symmetric"));
 	ui.cbXErrorType->addItem(i18n("Asymmetric"));
 
 	ui.cbYErrorType->addItem(i18n("No"));
 	ui.cbYErrorType->addItem(i18n("Symmetric"));
 	ui.cbYErrorType->addItem(i18n("Asymmetric"));
 
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, Qt::black);
 }
 
 void XYCurveDock::setModel() {
 	m_aspectTreeModel->enablePlottableColumnsOnly(true);
 	m_aspectTreeModel->enableShowPlotDesignation(true);
 
 	QList<const char*> list;
 	list << "Folder" << "Workbook" << "Datapicker" << "DatapickerCurve" << "Spreadsheet"
 		<< "FileDataSource" << "Column" << "Worksheet" << "CartesianPlot" << "XYFitCurve" << "CantorWorksheet";
 
 	if (cbXColumn) {
 		cbXColumn->setTopLevelClasses(list);
 		cbYColumn->setTopLevelClasses(list);
 	}
 	cbValuesColumn->setTopLevelClasses(list);
 	cbXErrorMinusColumn->setTopLevelClasses(list);
 	cbXErrorPlusColumn->setTopLevelClasses(list);
 	cbYErrorMinusColumn->setTopLevelClasses(list);
 	cbYErrorPlusColumn->setTopLevelClasses(list);
 
 	list.clear();
 	list << "Column" << "XYCurve";
 	m_aspectTreeModel->setSelectableAspects(list);
 
 	if (cbXColumn) {
 		cbXColumn->setModel(m_aspectTreeModel);
 		cbYColumn->setModel(m_aspectTreeModel);
 	}
 	cbValuesColumn->setModel(m_aspectTreeModel);
 	cbXErrorMinusColumn->setModel(m_aspectTreeModel);
 	cbXErrorPlusColumn->setModel(m_aspectTreeModel);
 	cbYErrorMinusColumn->setModel(m_aspectTreeModel);
 	cbYErrorPlusColumn->setModel(m_aspectTreeModel);
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing = true;
 	m_curvesList = list;
 	m_curve = list.first();
 	Q_ASSERT(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	setModel();
 	initGeneralTab();
 	initTabs();
 	m_initializing = false;
 }
 
 void XYCurveDock::initGeneralTab() {
 	DEBUG("XYCurveDock::initGeneralTab()");
 	//if there are more than one curve in the list, disable the content in the tab "general"
 	if (m_curvesList.size() == 1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.lXColumn->setEnabled(true);
 		cbXColumn->setEnabled(true);
 		uiGeneralTab.lYColumn->setEnabled(true);
 		cbYColumn->setEnabled(true);
 
 		DEBUG("setModelIndexFromAspect()");
 		this->setModelIndexFromAspect(cbXColumn, m_curve->xColumn());
 		this->setModelIndexFromAspect(cbYColumn, m_curve->yColumn());
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	} else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.lXColumn->setEnabled(false);
 		cbXColumn->setEnabled(false);
 		uiGeneralTab.lYColumn->setEnabled(false);
 		cbYColumn->setEnabled(false);
 
 		cbXColumn->setCurrentModelIndex(QModelIndex());
 		cbYColumn->setCurrentModelIndex(QModelIndex());
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_curve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_curve, SIGNAL(xColumnChanged(const AbstractColumn*)), this, SLOT(curveXColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(yColumnChanged(const AbstractColumn*)), this, SLOT(curveYColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(visibilityChanged(bool)), this, SLOT(curveVisibilityChanged(bool)));
 	DEBUG("XYCurveDock::initGeneralTab() DONE");
 }
 
 void XYCurveDock::initTabs() {
 	//if there are more than one curve in the list, disable the tab "general"
 	if (m_curvesList.size() == 1) {
 		this->setModelIndexFromAspect(cbValuesColumn, m_curve->valuesColumn());
 		this->setModelIndexFromAspect(cbXErrorPlusColumn, m_curve->xErrorPlusColumn());
 		this->setModelIndexFromAspect(cbXErrorMinusColumn, m_curve->xErrorMinusColumn());
 		this->setModelIndexFromAspect(cbYErrorPlusColumn, m_curve->yErrorPlusColumn());
 		this->setModelIndexFromAspect(cbYErrorMinusColumn, m_curve->yErrorMinusColumn());
 	} else {
 		cbValuesColumn->setCurrentModelIndex(QModelIndex());
 		cbXErrorPlusColumn->setCurrentModelIndex(QModelIndex());
 		cbXErrorMinusColumn->setCurrentModelIndex(QModelIndex());
 		cbYErrorPlusColumn->setCurrentModelIndex(QModelIndex());
 		cbYErrorMinusColumn->setCurrentModelIndex(QModelIndex());
 	}
 
 	//show the properties of the first curve
 	load();
 
 	//Slots
 
 	//Line-Tab
 	connect(m_curve, SIGNAL(lineTypeChanged(XYCurve::LineType)), this, SLOT(curveLineTypeChanged(XYCurve::LineType)));
 	connect(m_curve, SIGNAL(lineSkipGapsChanged(bool)), this, SLOT(curveLineSkipGapsChanged(bool)));
 	connect(m_curve, &XYCurve::lineIncreasingXOnlyChanged, this, &XYCurveDock::curveLineIncreasingXOnlyChanged);
 	connect(m_curve, SIGNAL(lineInterpolationPointsCountChanged(int)), this, SLOT(curveLineInterpolationPointsCountChanged(int)));
 	connect(m_curve, SIGNAL(linePenChanged(QPen)), this, SLOT(curveLinePenChanged(QPen)));
 	connect(m_curve, SIGNAL(lineOpacityChanged(qreal)), this, SLOT(curveLineOpacityChanged(qreal)));
 	connect(m_curve, SIGNAL(dropLineTypeChanged(XYCurve::DropLineType)), this, SLOT(curveDropLineTypeChanged(XYCurve::DropLineType)));
 	connect(m_curve, SIGNAL(dropLinePenChanged(QPen)), this, SLOT(curveDropLinePenChanged(QPen)));
 	connect(m_curve, SIGNAL(dropLineOpacityChanged(qreal)), this, SLOT(curveDropLineOpacityChanged(qreal)));
 
 	//Symbol-Tab
 	connect(m_curve, SIGNAL(symbolsStyleChanged(Symbol::Style)), this, SLOT(curveSymbolsStyleChanged(Symbol::Style)));
 	connect(m_curve, SIGNAL(symbolsSizeChanged(qreal)), this, SLOT(curveSymbolsSizeChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsRotationAngleChanged(qreal)), this, SLOT(curveSymbolsRotationAngleChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsOpacityChanged(qreal)), this, SLOT(curveSymbolsOpacityChanged(qreal)));
 	connect(m_curve, SIGNAL(symbolsBrushChanged(QBrush)), this, SLOT(curveSymbolsBrushChanged(QBrush)));
 	connect(m_curve, SIGNAL(symbolsPenChanged(QPen)), this, SLOT(curveSymbolsPenChanged(QPen)));
 
 	//Values-Tab
 	connect(m_curve, SIGNAL(valuesTypeChanged(XYCurve::ValuesType)), this, SLOT(curveValuesTypeChanged(XYCurve::ValuesType)));
 	connect(m_curve, SIGNAL(valuesColumnChanged(const AbstractColumn*)), this, SLOT(curveValuesColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(valuesPositionChanged(XYCurve::ValuesPosition)), this, SLOT(curveValuesPositionChanged(XYCurve::ValuesPosition)));
 	connect(m_curve, SIGNAL(valuesDistanceChanged(qreal)), this, SLOT(curveValuesDistanceChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesOpacityChanged(qreal)), this, SLOT(curveValuesOpacityChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesRotationAngleChanged(qreal)), this, SLOT(curveValuesRotationAngleChanged(qreal)));
 	connect(m_curve, SIGNAL(valuesPrefixChanged(QString)), this, SLOT(curveValuesPrefixChanged(QString)));
 	connect(m_curve, SIGNAL(valuesSuffixChanged(QString)), this, SLOT(curveValuesSuffixChanged(QString)));
 	connect(m_curve, SIGNAL(valuesFontChanged(QFont)), this, SLOT(curveValuesFontChanged(QFont)));
 	connect(m_curve, SIGNAL(valuesColorChanged(QColor)), this, SLOT(curveValuesColorChanged(QColor)));
 
 	//Filling-Tab
 	connect( m_curve, SIGNAL(fillingPositionChanged(XYCurve::FillingPosition)), this, SLOT(curveFillingPositionChanged(XYCurve::FillingPosition)) );
 	connect( m_curve, SIGNAL(fillingTypeChanged(PlotArea::BackgroundType)), this, SLOT(curveFillingTypeChanged(PlotArea::BackgroundType)) );
 	connect( m_curve, SIGNAL(fillingColorStyleChanged(PlotArea::BackgroundColorStyle)), this, SLOT(curveFillingColorStyleChanged(PlotArea::BackgroundColorStyle)) );
 	connect( m_curve, SIGNAL(fillingImageStyleChanged(PlotArea::BackgroundImageStyle)), this, SLOT(curveFillingImageStyleChanged(PlotArea::BackgroundImageStyle)) );
 	connect( m_curve, SIGNAL(fillingBrushStyleChanged(Qt::BrushStyle)), this, SLOT(curveFillingBrushStyleChanged(Qt::BrushStyle)) );
 	connect( m_curve, SIGNAL(fillingFirstColorChanged(QColor&)), this, SLOT(curveFillingFirstColorChanged(QColor&)) );
 	connect( m_curve, SIGNAL(fillingSecondColorChanged(QColor&)), this, SLOT(curveFillingSecondColorChanged(QColor&)) );
 	connect( m_curve, SIGNAL(fillingFileNameChanged(QString&)), this, SLOT(curveFillingFileNameChanged(QString&)) );
 	connect( m_curve, SIGNAL(fillingOpacityChanged(float)), this, SLOT(curveFillingOpacityChanged(float)) );
 
 	//"Error bars"-Tab
 	connect(m_curve, SIGNAL(xErrorTypeChanged(XYCurve::ErrorType)), this, SLOT(curveXErrorTypeChanged(XYCurve::ErrorType)));
 	connect(m_curve, SIGNAL(xErrorPlusColumnChanged(const AbstractColumn*)), this, SLOT(curveXErrorPlusColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(xErrorMinusColumnChanged(const AbstractColumn*)), this, SLOT(curveXErrorMinusColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(yErrorTypeChanged(XYCurve::ErrorType)), this, SLOT(curveYErrorTypeChanged(XYCurve::ErrorType)));
 	connect(m_curve, SIGNAL(yErrorPlusColumnChanged(const AbstractColumn*)), this, SLOT(curveYErrorPlusColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(yErrorMinusColumnChanged(const AbstractColumn*)), this, SLOT(curveYErrorMinusColumnChanged(const AbstractColumn*)));
 	connect(m_curve, SIGNAL(errorBarsCapSizeChanged(qreal)), this, SLOT(curveErrorBarsCapSizeChanged(qreal)));
 	connect(m_curve, SIGNAL(errorBarsTypeChanged(XYCurve::ErrorBarsType)), this, SLOT(curveErrorBarsTypeChanged(XYCurve::ErrorBarsType)));
 	connect(m_curve, SIGNAL(errorBarsPenChanged(QPen)), this, SLOT(curveErrorBarsPenChanged(QPen)));
 	connect(m_curve, SIGNAL(errorBarsOpacityChanged(qreal)), this, SLOT(curveErrorBarsOpacityChanged(qreal)));
 }
 
 /*!
   depending on the currently selected values column type (column mode) updates the widgets for the values column format,
   shows/hides the allowed widgets, fills the corresponding combobox with the possible entries.
   Called when the values column was changed.
 
   synchronize this function with ColumnDock::updateFormat.
 */
 void XYCurveDock::updateValuesFormatWidgets(const AbstractColumn::ColumnMode columnMode) {
 	ui.cbValuesFormat->clear();
 
 	switch (columnMode) {
 	case AbstractColumn::Numeric:
 		ui.cbValuesFormat->addItem(i18n("Decimal"), QVariant('f'));
 		ui.cbValuesFormat->addItem(i18n("Scientific (e)"), QVariant('e'));
 		ui.cbValuesFormat->addItem(i18n("Scientific (E)"), QVariant('E'));
 		ui.cbValuesFormat->addItem(i18n("Automatic (e)"), QVariant('g'));
 		ui.cbValuesFormat->addItem(i18n("Automatic (E)"), QVariant('G'));
 		break;
 	case AbstractColumn::Integer:
 		break;
 	case AbstractColumn::Text:
 		ui.cbValuesFormat->addItem(i18n("Text"), QVariant());
 		break;
 	case AbstractColumn::Month:
 		ui.cbValuesFormat->addItem(i18n("Number without Leading Zero"), QVariant("M"));
 		ui.cbValuesFormat->addItem(i18n("Number with Leading Zero"), QVariant("MM"));
 		ui.cbValuesFormat->addItem(i18n("Abbreviated Month Name"), QVariant("MMM"));
 		ui.cbValuesFormat->addItem(i18n("Full Month Name"), QVariant("MMMM"));
 		break;
 	case AbstractColumn::Day:
 		ui.cbValuesFormat->addItem(i18n("Number without Leading Zero"), QVariant("d"));
 		ui.cbValuesFormat->addItem(i18n("Number with Leading Zero"), QVariant("dd"));
 		ui.cbValuesFormat->addItem(i18n("Abbreviated Day Name"), QVariant("ddd"));
 		ui.cbValuesFormat->addItem(i18n("Full Day Name"), QVariant("dddd"));
 		break;
 	case AbstractColumn::DateTime: {
-			for (const auto& s: AbstractColumn::dateFormats())
+			for (const auto& s : AbstractColumn::dateFormats())
 				ui.cbValuesFormat->addItem(s, QVariant(s));
 
-			for (const auto& s: AbstractColumn::timeFormats())
+			for (const auto& s : AbstractColumn::timeFormats())
 				ui.cbValuesFormat->addItem(s, QVariant(s));
 
-			for (const auto& s1: AbstractColumn::dateFormats()) {
-				for (const auto& s2: AbstractColumn::timeFormats())
+			for (const auto& s1 : AbstractColumn::dateFormats()) {
+				for (const auto& s2 : AbstractColumn::timeFormats())
 					ui.cbValuesFormat->addItem(s1 + ' ' + s2, QVariant(s1 + ' ' + s2));
 			}
 			break;
 		}
 	}
 
 	if (columnMode == AbstractColumn::Numeric) {
 		ui.lValuesPrecision->show();
 		ui.sbValuesPrecision->show();
 	} else {
 		ui.lValuesPrecision->hide();
 		ui.sbValuesPrecision->hide();
 	}
 
 	if (columnMode == AbstractColumn::Text) {
 		ui.lValuesFormatTop->hide();
 		ui.lValuesFormat->hide();
 		ui.cbValuesFormat->hide();
 	} else {
 		ui.lValuesFormatTop->show();
 		ui.lValuesFormat->show();
 		ui.cbValuesFormat->show();
 	}
 
 	if (columnMode == AbstractColumn::DateTime) {
 		ui.cbValuesFormat->setCurrentItem("yyyy-MM-dd hh:mm:ss.zzz");
 		ui.cbValuesFormat->setEditable(true);
 	} else {
 		ui.cbValuesFormat->setCurrentIndex(0);
 		ui.cbValuesFormat->setEditable(false);
 	}
 }
 
 /*!
   shows the formatting properties of the column \c column.
   Called, when a new column for the values was selected - either by changing the type of the values (none, x, y, etc.) or
   by selecting a new custom column for the values.
 */
 void XYCurveDock::showValuesColumnFormat(const Column* column) {
 	if (!column) {
 		// no valid column is available
 		// -> hide all the format properties widgets (equivalent to showing the properties of the column mode "Text")
 		this->updateValuesFormatWidgets(AbstractColumn::Text);
 	} else {
 		AbstractColumn::ColumnMode columnMode = column->columnMode();
 
 		//update the format widgets for the new column mode
 		this->updateValuesFormatWidgets(columnMode);
 
 		//show the actual formatting properties
 		switch (columnMode) {
 		case AbstractColumn::Numeric: {
-			const auto filter = static_cast<Double2StringFilter*>(column->outputFilter());
+			const auto* filter = static_cast<Double2StringFilter*>(column->outputFilter());
 			ui.cbValuesFormat->setCurrentIndex(ui.cbValuesFormat->findData(filter->numericFormat()));
 			ui.sbValuesPrecision->setValue(filter->numDigits());
 			break;
 		}
 		case AbstractColumn::Integer:
 		case AbstractColumn::Text:
 			break;
 		case AbstractColumn::Month:
 		case AbstractColumn::Day:
 		case AbstractColumn::DateTime: {
-			const auto filter = static_cast<DateTime2StringFilter*>(column->outputFilter());
+			const auto* filter = static_cast<DateTime2StringFilter*>(column->outputFilter());
 			DEBUG("	column values format = " << filter->format().toStdString());
 			ui.cbValuesFormat->setCurrentIndex(ui.cbValuesFormat->findData(filter->format()));
 			break;
 		}
 		}
 	}
 }
 
 void XYCurveDock::setModelIndexFromAspect(TreeViewComboBox* cb, const AbstractAspect* aspect) {
 	DEBUG("XYCurveDock::setModelIndexFromAspect()");
 	if (aspect)
 		cb->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(aspect));
 	else
 		cb->setCurrentModelIndex(QModelIndex());
 }
 
 //*************************************************************
 //********** SLOTs for changes triggered in XYCurveDock ********
 //*************************************************************
 void XYCurveDock::retranslateUi() {
 	ui.lLineIncreasingXOnly->setToolTip(i18n("Connect data points only for strictly increasing values of X"));
 	ui.chkLineIncreasingXOnly->setToolTip(i18n("Connect data points only for strictly increasing values of X"));
 	//TODO:
 // 	uiGeneralTab.lName->setText(i18n("Name"));
 // 	uiGeneralTab.lComment->setText(i18n("Comment"));
 // 	uiGeneralTab.chkVisible->setText(i18n("Visible"));
 // 	uiGeneralTab.lXColumn->setText(i18n("x-data"));
 // 	uiGeneralTab.lYColumn->setText(i18n("y-data"));
 
 	//TODO updatePenStyles, updateBrushStyles for all comboboxes
 }
 
 // "General"-tab
 void XYCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYCurveDock::xColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = nullptr;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve : m_curvesList)
 		curve->setXColumn(column);
 }
 
 void XYCurveDock::yColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = nullptr;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for (auto* curve : m_curvesList)
 		curve->setYColumn(column);
 }
 
 void XYCurveDock::visibilityChanged(bool state) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setVisible(state);
 }
 
 // "Line"-tab
 void XYCurveDock::lineTypeChanged(int index) {
 	const auto lineType = XYCurve::LineType(index);
 
 	if ( lineType == XYCurve::NoLine) {
 		ui.chkLineSkipGaps->setEnabled(false);
 		ui.cbLineStyle->setEnabled(false);
 		ui.kcbLineColor->setEnabled(false);
 		ui.sbLineWidth->setEnabled(false);
 		ui.sbLineOpacity->setEnabled(false);
 		ui.lLineInterpolationPointsCount->hide();
 		ui.sbLineInterpolationPointsCount->hide();
 	} else {
 		ui.chkLineSkipGaps->setEnabled(true);
 		ui.cbLineStyle->setEnabled(true);
 		ui.kcbLineColor->setEnabled(true);
 		ui.sbLineWidth->setEnabled(true);
 		ui.sbLineOpacity->setEnabled(true);
 
 		if (lineType == XYCurve::SplineCubicNatural || lineType == XYCurve::SplineCubicPeriodic
 		        || lineType == XYCurve::SplineAkimaNatural || lineType == XYCurve::SplineAkimaPeriodic) {
 			ui.lLineInterpolationPointsCount->show();
 			ui.sbLineInterpolationPointsCount->show();
 			ui.lLineSkipGaps->hide();
 			ui.chkLineSkipGaps->hide();
 		} else {
 			ui.lLineInterpolationPointsCount->hide();
 			ui.sbLineInterpolationPointsCount->hide();
 			ui.lLineSkipGaps->show();
 			ui.chkLineSkipGaps->show();
 		}
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setLineType(lineType);
 }
 
 void XYCurveDock::lineSkipGapsChanged(bool skip) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setLineSkipGaps(skip);
 }
 
 void XYCurveDock::lineIncreasingXOnlyChanged(bool incr) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setLineIncreasingXOnly(incr);
 }
 
 void XYCurveDock::lineInterpolationPointsCountChanged(int count) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setLineInterpolationPointsCount(count);
 }
 
 void XYCurveDock::lineStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	const auto penStyle = Qt::PenStyle(index);
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setStyle(penStyle);
 		curve->setLinePen(pen);
 	}
 }
 
 void XYCurveDock::lineColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setColor(color);
 		curve->setLinePen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, color);
 	m_initializing = false;
 }
 
 void XYCurveDock::lineWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->linePen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setLinePen(pen);
 	}
 }
 
 void XYCurveDock::lineOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setLineOpacity(opacity);
 }
 
 void XYCurveDock::dropLineTypeChanged(int index) {
 	const auto dropLineType = XYCurve::DropLineType(index);
 
 	if ( dropLineType == XYCurve::NoDropLine) {
 		ui.cbDropLineStyle->setEnabled(false);
 		ui.kcbDropLineColor->setEnabled(false);
 		ui.sbDropLineWidth->setEnabled(false);
 		ui.sbDropLineOpacity->setEnabled(false);
 	} else {
 		ui.cbDropLineStyle->setEnabled(true);
 		ui.kcbDropLineColor->setEnabled(true);
 		ui.sbDropLineWidth->setEnabled(true);
 		ui.sbDropLineOpacity->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setDropLineType(dropLineType);
 }
 
 void XYCurveDock::dropLineStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto penStyle = Qt::PenStyle(index);
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->dropLinePen();
 		pen.setStyle(penStyle);
 		curve->setDropLinePen(pen);
 	}
 }
 
 void XYCurveDock::dropLineColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->dropLinePen();
 		pen.setColor(color);
 		curve->setDropLinePen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbDropLineStyle, color);
 	m_initializing = false;
 }
 
 void XYCurveDock::dropLineWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->dropLinePen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setDropLinePen(pen);
 	}
 }
 
 void XYCurveDock::dropLineOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setDropLineOpacity(opacity);
 }
 
 //"Symbol"-tab
 void XYCurveDock::symbolsStyleChanged(int index) {
 	const auto style = Symbol::Style(index);
 
 	if (style == Symbol::NoSymbols) {
 		ui.sbSymbolSize->setEnabled(false);
 		ui.sbSymbolRotation->setEnabled(false);
 		ui.sbSymbolOpacity->setEnabled(false);
 
 		ui.kcbSymbolFillingColor->setEnabled(false);
 		ui.cbSymbolFillingStyle->setEnabled(false);
 
 		ui.cbSymbolBorderStyle->setEnabled(false);
 		ui.kcbSymbolBorderColor->setEnabled(false);
 		ui.sbSymbolBorderWidth->setEnabled(false);
 	} else {
 		ui.sbSymbolSize->setEnabled(true);
 		ui.sbSymbolRotation->setEnabled(true);
 		ui.sbSymbolOpacity->setEnabled(true);
 
 		//enable/disable the symbol filling options in the GUI depending on the currently selected symbol.
 		if (style != Symbol::Line && style != Symbol::Cross) {
 			ui.cbSymbolFillingStyle->setEnabled(true);
 			bool noBrush = (Qt::BrushStyle(ui.cbSymbolFillingStyle->currentIndex()) == Qt::NoBrush);
 			ui.kcbSymbolFillingColor->setEnabled(!noBrush);
 		} else {
 			ui.kcbSymbolFillingColor->setEnabled(false);
 			ui.cbSymbolFillingStyle->setEnabled(false);
 		}
 
 		ui.cbSymbolBorderStyle->setEnabled(true);
 		bool noLine = (Qt::PenStyle(ui.cbSymbolBorderStyle->currentIndex()) == Qt::NoPen);
 		ui.kcbSymbolBorderColor->setEnabled(!noLine);
 		ui.sbSymbolBorderWidth->setEnabled(!noLine);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsStyle(style);
 }
 
 void XYCurveDock::symbolsSizeChanged(double value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsSize( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void XYCurveDock::symbolsRotationChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsRotationAngle(value);
 }
 
 void XYCurveDock::symbolsOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setSymbolsOpacity(opacity);
 }
 
 void XYCurveDock::symbolsFillingStyleChanged(int index) {
 	const auto brushStyle = Qt::BrushStyle(index);
 	ui.kcbSymbolFillingColor->setEnabled(!(brushStyle == Qt::NoBrush));
 
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	for (auto* curve : m_curvesList) {
 		brush = curve->symbolsBrush();
 		brush.setStyle(brushStyle);
 		curve->setSymbolsBrush(brush);
 	}
 }
 
 void XYCurveDock::symbolsFillingColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QBrush brush;
 	for (auto* curve : m_curvesList) {
 		brush = curve->symbolsBrush();
 		brush.setColor(color);
 		curve->setSymbolsBrush(brush);
 	}
 
 	m_initializing = true;
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, color );
 	m_initializing = false;
 }
 
 void XYCurveDock::symbolsBorderStyleChanged(int index) {
 	const auto penStyle = Qt::PenStyle(index);
 
 	if ( penStyle == Qt::NoPen ) {
 		ui.kcbSymbolBorderColor->setEnabled(false);
 		ui.sbSymbolBorderWidth->setEnabled(false);
 	} else {
 		ui.kcbSymbolBorderColor->setEnabled(true);
 		ui.sbSymbolBorderWidth->setEnabled(true);
 	}
 
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->symbolsPen();
 		pen.setStyle(penStyle);
 		curve->setSymbolsPen(pen);
 	}
 }
 
 void XYCurveDock::symbolsBorderColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->symbolsPen();
 		pen.setColor(color);
 		curve->setSymbolsPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, color);
 	m_initializing = false;
 }
 
 void XYCurveDock::symbolsBorderWidthChanged(double value) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->symbolsPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setSymbolsPen(pen);
 	}
 }
 
 //Values-tab
 
 /*!
   called when the type of the values (none, x, y, (x,y) etc.) was changed.
 */
 void XYCurveDock::valuesTypeChanged(int index) {
 	const auto valuesType = XYCurve::ValuesType(index);
 
 	if (valuesType == XYCurve::NoValues) {
 		//no values are to paint -> deactivate all the pertinent widgets
 		ui.cbValuesPosition->setEnabled(false);
 		ui.lValuesColumn->hide();
 		cbValuesColumn->hide();
 		ui.sbValuesDistance->setEnabled(false);
 		ui.sbValuesRotation->setEnabled(false);
 		ui.sbValuesOpacity->setEnabled(false);
 		ui.cbValuesFormat->setEnabled(false);
 		ui.cbValuesFormat->setEnabled(false);
 		ui.sbValuesPrecision->setEnabled(false);
 		ui.leValuesPrefix->setEnabled(false);
 		ui.leValuesSuffix->setEnabled(false);
 		ui.kfrValuesFont->setEnabled(false);
 		ui.kcbValuesColor->setEnabled(false);
 	} else {
 		ui.cbValuesPosition->setEnabled(true);
 		ui.sbValuesDistance->setEnabled(true);
 		ui.sbValuesRotation->setEnabled(true);
 		ui.sbValuesOpacity->setEnabled(true);
 		ui.cbValuesFormat->setEnabled(true);
 		ui.sbValuesPrecision->setEnabled(true);
 		ui.leValuesPrefix->setEnabled(true);
 		ui.leValuesSuffix->setEnabled(true);
 		ui.kfrValuesFont->setEnabled(true);
 		ui.kcbValuesColor->setEnabled(true);
 
 		const Column* column;
 		if (valuesType == XYCurve::ValuesCustomColumn) {
 			ui.lValuesColumn->show();
 			cbValuesColumn->show();
 
 			column= static_cast<Column*>(cbValuesColumn->currentModelIndex().internalPointer());
 		} else {
 			ui.lValuesColumn->hide();
 			cbValuesColumn->hide();
 
 			if (valuesType == XYCurve::ValuesY)
 				column = static_cast<const Column*>(m_curve->yColumn());
 			else
 				column = static_cast<const Column*>(m_curve->xColumn());
 		}
 		this->showValuesColumnFormat(column);
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesType(valuesType);
 }
 
 /*!
   called when the custom column for the values was changed.
 */
 void XYCurveDock::valuesColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto column = static_cast<Column*>(index.internalPointer());
+	auto* column = static_cast<Column*>(index.internalPointer());
 	this->showValuesColumnFormat(column);
 
 	for (auto* curve : m_curvesList) {
 		//TODO save also the format of the currently selected column for the values (precision etc.)
 		curve->setValuesColumn(column);
 	}
 }
 
 void XYCurveDock::valuesPositionChanged(int index) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesPosition(XYCurve::ValuesPosition(index));
 }
 
 void XYCurveDock::valuesDistanceChanged(double  value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesDistance( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 }
 
 void XYCurveDock::valuesRotationChanged(int value) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesRotationAngle(value);
 }
 
 void XYCurveDock::valuesOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setValuesOpacity(opacity);
 }
 
 void XYCurveDock::valuesPrefixChanged() {
 	if (m_initializing)
 		return;
 
 	QString prefix = ui.leValuesPrefix->text();
 	for (auto* curve : m_curvesList)
 		curve->setValuesPrefix(prefix);
 }
 
 void XYCurveDock::valuesSuffixChanged() {
 	if (m_initializing)
 		return;
 
 	QString suffix = ui.leValuesSuffix->text();
 	for (auto* curve : m_curvesList)
 		curve->setValuesSuffix(suffix);
 }
 
 void XYCurveDock::valuesFontChanged(const QFont& font) {
 	if (m_initializing)
 		return;
 
 	QFont valuesFont = font;
 	valuesFont.setPixelSize( Worksheet::convertToSceneUnits(font.pointSizeF(), Worksheet::Point) );
 	for (auto* curve : m_curvesList)
 		curve->setValuesFont(valuesFont);
 }
 
 void XYCurveDock::valuesColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setValuesColor(color);
 }
 
 //Filling-tab
 void XYCurveDock::fillingPositionChanged(int index) {
 	const auto fillingPosition = XYCurve::FillingPosition(index);
 
 	bool b = (fillingPosition != XYCurve::NoFilling);
 	ui.cbFillingType->setEnabled(b);
 	ui.cbFillingColorStyle->setEnabled(b);
 	ui.cbFillingBrushStyle->setEnabled(b);
 	ui.cbFillingImageStyle->setEnabled(b);
 	ui.kcbFillingFirstColor->setEnabled(b);
 	ui.kcbFillingSecondColor->setEnabled(b);
 	ui.leFillingFileName->setEnabled(b);
 	ui.bFillingOpen->setEnabled(b);
 	ui.sbFillingOpacity->setEnabled(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingPosition(fillingPosition);
 }
 
 void XYCurveDock::fillingTypeChanged(int index) {
 	const auto type = (PlotArea::BackgroundType)index;
 
 	if (type == PlotArea::Color) {
 		ui.lFillingColorStyle->show();
 		ui.cbFillingColorStyle->show();
 		ui.lFillingImageStyle->hide();
 		ui.cbFillingImageStyle->hide();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 
 		ui.lFillingFileName->hide();
 		ui.leFillingFileName->hide();
 		ui.bFillingOpen->hide();
 
 		ui.lFillingFirstColor->show();
 		ui.kcbFillingFirstColor->show();
 
 		auto style = (PlotArea::BackgroundColorStyle) ui.cbFillingColorStyle->currentIndex();
 		if (style == PlotArea::SingleColor) {
 			ui.lFillingFirstColor->setText(i18n("Color:"));
 			ui.lFillingSecondColor->hide();
 			ui.kcbFillingSecondColor->hide();
 		} else {
 			ui.lFillingFirstColor->setText(i18n("First color:"));
 			ui.lFillingSecondColor->show();
 			ui.kcbFillingSecondColor->show();
 		}
 	} else if (type == PlotArea::Image) {
 		ui.lFillingColorStyle->hide();
 		ui.cbFillingColorStyle->hide();
 		ui.lFillingImageStyle->show();
 		ui.cbFillingImageStyle->show();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 		ui.lFillingFileName->show();
 		ui.leFillingFileName->show();
 		ui.bFillingOpen->show();
 
 		ui.lFillingFirstColor->hide();
 		ui.kcbFillingFirstColor->hide();
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	} else if (type == PlotArea::Pattern) {
 		ui.lFillingFirstColor->setText(i18n("Color:"));
 		ui.lFillingColorStyle->hide();
 		ui.cbFillingColorStyle->hide();
 		ui.lFillingImageStyle->hide();
 		ui.cbFillingImageStyle->hide();
 		ui.lFillingBrushStyle->show();
 		ui.cbFillingBrushStyle->show();
 		ui.lFillingFileName->hide();
 		ui.leFillingFileName->hide();
 		ui.bFillingOpen->hide();
 
 		ui.lFillingFirstColor->show();
 		ui.kcbFillingFirstColor->show();
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingType(type);
 }
 
 void XYCurveDock::fillingColorStyleChanged(int index) {
 	const auto style = (PlotArea::BackgroundColorStyle)index;
 
 	if (style == PlotArea::SingleColor) {
 		ui.lFillingFirstColor->setText(i18n("Color:"));
 		ui.lFillingSecondColor->hide();
 		ui.kcbFillingSecondColor->hide();
 	} else {
 		ui.lFillingFirstColor->setText(i18n("First color:"));
 		ui.lFillingSecondColor->show();
 		ui.kcbFillingSecondColor->show();
 		ui.lFillingBrushStyle->hide();
 		ui.cbFillingBrushStyle->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingColorStyle(style);
 }
 
 void XYCurveDock::fillingImageStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto style = (PlotArea::BackgroundImageStyle)index;
 	for (auto* curve : m_curvesList)
 		curve->setFillingImageStyle(style);
 }
 
 void XYCurveDock::fillingBrushStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto style = (Qt::BrushStyle)index;
 	for (auto* curve : m_curvesList)
 		curve->setFillingBrushStyle(style);
 }
 
 void XYCurveDock::fillingFirstColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingFirstColor(c);
 
 	m_initializing = true;
 	GuiTools::updateBrushStyles(ui.cbFillingBrushStyle, c);
 	m_initializing = false;
 }
 
 void XYCurveDock::fillingSecondColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingSecondColor(c);
 }
 
 /*!
 	opens a file dialog and lets the user select the image file.
 */
 void XYCurveDock::selectFile() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "XYCurveDock");
 	QString dir = conf.readEntry("LastImageDir", "");
 
 	QString formats;
 	for (const QByteArray& format : QImageReader::supportedImageFormats()) {
 		QString f = "*." + QString(format.constData());
 		formats.isEmpty() ? formats+=f : formats+=' '+f;
 	}
 
 	QString path = QFileDialog::getOpenFileName(this, i18n("Select the image file"), dir, i18n("Images (%1)", formats));
 	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("LastImageDir", newDir);
 	}
 
 	ui.leFillingFileName->setText( path );
 
 	for (auto* curve : m_curvesList)
 		curve->setFillingFileName(path);
 }
 
 void XYCurveDock::fileNameChanged() {
 	if (m_initializing)
 		return;
 
 	QString fileName = ui.leFillingFileName->text();
 	for (auto* curve : m_curvesList)
 		curve->setFillingFileName(fileName);
 }
 
 void XYCurveDock::fillingOpacityChanged(int value) {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setFillingOpacity(opacity);
 }
 
 //"Error bars"-Tab
 void XYCurveDock::xErrorTypeChanged(int index) const {
 	if (index == 0) {
 		//no error
 		ui.lXErrorDataPlus->setVisible(false);
 		cbXErrorPlusColumn->setVisible(false);
 		ui.lXErrorDataMinus->setVisible(false);
 		cbXErrorMinusColumn->setVisible(false);
 	} else if (index == 1) {
 		//symmetric error
 		ui.lXErrorDataPlus->setVisible(true);
 		cbXErrorPlusColumn->setVisible(true);
 		ui.lXErrorDataMinus->setVisible(false);
 		cbXErrorMinusColumn->setVisible(false);
 		ui.lXErrorDataPlus->setText(i18n("Data, +-"));
 	} else if (index == 2) {
 		//asymmetric error
 		ui.lXErrorDataPlus->setVisible(true);
 		cbXErrorPlusColumn->setVisible(true);
 		ui.lXErrorDataMinus->setVisible(true);
 		cbXErrorMinusColumn->setVisible(true);
 		ui.lXErrorDataPlus->setText(i18n("Data, +"));
 	}
 
 	bool b = (index!=0 || ui.cbYErrorType->currentIndex()!=0);
 	ui.lErrorFormat->setVisible(b);
 	ui.lErrorBarsType->setVisible(b);
 	ui.cbErrorBarsType->setVisible(b);
 	ui.lErrorBarsStyle->setVisible(b);
 	ui.cbErrorBarsStyle->setVisible(b);
 	ui.lErrorBarsColor->setVisible(b);
 	ui.kcbErrorBarsColor->setVisible(b);
 	ui.lErrorBarsWidth->setVisible(b);
 	ui.sbErrorBarsWidth->setVisible(b);
 	ui.lErrorBarsOpacity->setVisible(b);
 	ui.sbErrorBarsOpacity->setVisible(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setXErrorType(XYCurve::ErrorType(index));
 }
 
 void XYCurveDock::xErrorPlusColumnChanged(const QModelIndex& index) const {
 	Q_UNUSED(index);
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 	Q_ASSERT(column);
 
 	for (auto* curve : m_curvesList)
 		curve->setXErrorPlusColumn(column);
 }
 
 void XYCurveDock::xErrorMinusColumnChanged(const QModelIndex& index) const {
 	Q_UNUSED(index);
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 	Q_ASSERT(column);
 
 	for (auto* curve : m_curvesList)
 		curve->setXErrorMinusColumn(column);
 }
 
 void XYCurveDock::yErrorTypeChanged(int index) const {
 	if (index == 0) {
 		//no error
 		ui.lYErrorDataPlus->setVisible(false);
 		cbYErrorPlusColumn->setVisible(false);
 		ui.lYErrorDataMinus->setVisible(false);
 		cbYErrorMinusColumn->setVisible(false);
 	} else if (index == 1) {
 		//symmetric error
 		ui.lYErrorDataPlus->setVisible(true);
 		cbYErrorPlusColumn->setVisible(true);
 		ui.lYErrorDataMinus->setVisible(false);
 		cbYErrorMinusColumn->setVisible(false);
 		ui.lYErrorDataPlus->setText(i18n("Data, +-"));
 	} else if (index == 2) {
 		//asymmetric error
 		ui.lYErrorDataPlus->setVisible(true);
 		cbYErrorPlusColumn->setVisible(true);
 		ui.lYErrorDataMinus->setVisible(true);
 		cbYErrorMinusColumn->setVisible(true);
 		ui.lYErrorDataPlus->setText(i18n("Data, +"));
 	}
 
 	bool b = (index!=0 || ui.cbXErrorType->currentIndex()!=0);
 	ui.lErrorFormat->setVisible(b);
 	ui.lErrorBarsType->setVisible(b);
 	ui.cbErrorBarsType->setVisible(b);
 	ui.lErrorBarsStyle->setVisible(b);
 	ui.cbErrorBarsStyle->setVisible(b);
 	ui.lErrorBarsColor->setVisible(b);
 	ui.kcbErrorBarsColor->setVisible(b);
 	ui.lErrorBarsWidth->setVisible(b);
 	ui.sbErrorBarsWidth->setVisible(b);
 	ui.lErrorBarsOpacity->setVisible(b);
 	ui.sbErrorBarsOpacity->setVisible(b);
 
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setYErrorType(XYCurve::ErrorType(index));
 }
 
 void XYCurveDock::yErrorPlusColumnChanged(const QModelIndex& index) const {
 	Q_UNUSED(index);
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 	Q_ASSERT(column);
 
 	for (auto* curve : m_curvesList)
 		curve->setYErrorPlusColumn(column);
 }
 
 void XYCurveDock::yErrorMinusColumnChanged(const QModelIndex& index) const {
 	Q_UNUSED(index);
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 	Q_ASSERT(column);
 
 	for (auto* curve : m_curvesList)
 		curve->setYErrorMinusColumn(column);
 }
 
 void XYCurveDock::errorBarsTypeChanged(int index) const {
 	auto type = XYCurve::ErrorBarsType(index);
 	bool b = (type == XYCurve::ErrorBarsWithEnds);
 	ui.lErrorBarsCapSize->setVisible(b);
 	ui.sbErrorBarsCapSize->setVisible(b);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsType(type);
 }
 
 void XYCurveDock::errorBarsCapSizeChanged(double value) const {
 	if (m_initializing)
 		return;
 
 	float size = Worksheet::convertToSceneUnits(value, Worksheet::Point);
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsCapSize(size);
 }
 
 void XYCurveDock::errorBarsStyleChanged(int index) const {
 	if (m_initializing)
 		return;
 
 	auto penStyle = Qt::PenStyle(index);
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setStyle(penStyle);
 		curve->setErrorBarsPen(pen);
 	}
 }
 
 void XYCurveDock::errorBarsColorChanged(const QColor& color) {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setColor(color);
 		curve->setErrorBarsPen(pen);
 	}
 
 	m_initializing = true;
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, color);
 	m_initializing = false;
 }
 
 void XYCurveDock::errorBarsWidthChanged(double value) const {
 	if (m_initializing)
 		return;
 
 	QPen pen;
 	for (auto* curve : m_curvesList) {
 		pen = curve->errorBarsPen();
 		pen.setWidthF( Worksheet::convertToSceneUnits(value, Worksheet::Point) );
 		curve->setErrorBarsPen(pen);
 	}
 }
 
 void XYCurveDock::errorBarsOpacityChanged(int value) const {
 	if (m_initializing)
 		return;
 
 	qreal opacity = (float)value/100.;
 	for (auto* curve : m_curvesList)
 		curve->setErrorBarsOpacity(opacity);
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYCurveDock::curveXColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbXColumn, column);
 	m_initializing = false;
 }
 
 void XYCurveDock::curveYColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbYColumn, column);
 	m_initializing = false;
 }
 
 void XYCurveDock::curveVisibilityChanged(bool on) {
 	m_initializing = true;
 	uiGeneralTab.chkVisible->setChecked(on);
 	m_initializing = false;
 }
 
 //Line-Tab
 void XYCurveDock::curveLineTypeChanged(XYCurve::LineType type) {
 	m_initializing = true;
 	ui.cbLineType->setCurrentIndex( (int) type);
 	m_initializing = false;
 }
 void XYCurveDock::curveLineSkipGapsChanged(bool skip) {
 	m_initializing = true;
 	ui.chkLineSkipGaps->setChecked(skip);
 	m_initializing = false;
 }
 void XYCurveDock::curveLineIncreasingXOnlyChanged(bool incr) {
 	m_initializing = true;
 	ui.chkLineIncreasingXOnly->setChecked(incr);
 	m_initializing = false;
 }
 void XYCurveDock::curveLineInterpolationPointsCountChanged(int count) {
 	m_initializing = true;
 	ui.sbLineInterpolationPointsCount->setValue(count);
 	m_initializing = false;
 }
 void XYCurveDock::curveLinePenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbLineStyle->setCurrentIndex( (int)pen.style());
 	ui.kcbLineColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbLineStyle, pen.color());
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits( pen.widthF(), Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveLineOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbLineOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void XYCurveDock::curveDropLineTypeChanged(XYCurve::DropLineType type) {
 	m_initializing = true;
 	ui.cbDropLineType->setCurrentIndex( (int)type );
 	m_initializing = false;
 }
 void XYCurveDock::curveDropLinePenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbDropLineStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbDropLineColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbDropLineStyle, pen.color());
 	ui.sbDropLineWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveDropLineOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbDropLineOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //Symbol-Tab
 void XYCurveDock::curveSymbolsStyleChanged(Symbol::Style style) {
 	m_initializing = true;
 	ui.cbSymbolStyle->setCurrentIndex((int)style);
 	m_initializing = false;
 }
 void XYCurveDock::curveSymbolsSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveSymbolsRotationAngleChanged(qreal angle) {
 	m_initializing = true;
 	ui.sbSymbolRotation->setValue(angle);
 	m_initializing = false;
 }
 void XYCurveDock::curveSymbolsOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbSymbolOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void XYCurveDock::curveSymbolsBrushChanged(const QBrush& brush) {
 	m_initializing = true;
 	ui.cbSymbolFillingStyle->setCurrentIndex((int) brush.style());
 	ui.kcbSymbolFillingColor->setColor(brush.color());
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, brush.color());
 	m_initializing = false;
 }
 void XYCurveDock::curveSymbolsPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbSymbolBorderStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbSymbolBorderColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, pen.color());
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(), Worksheet::Point));
 	m_initializing = false;
 }
 
 //Values-Tab
 void XYCurveDock::curveValuesTypeChanged(XYCurve::ValuesType type) {
 	m_initializing = true;
 	ui.cbValuesType->setCurrentIndex((int) type);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbValuesColumn, column);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesPositionChanged(XYCurve::ValuesPosition position) {
 	m_initializing = true;
 	ui.cbValuesPosition->setCurrentIndex((int) position);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesDistanceChanged(qreal distance) {
 	m_initializing = true;
 	ui.sbValuesDistance->setValue( Worksheet::convertFromSceneUnits(distance, Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesRotationAngleChanged(qreal angle) {
 	m_initializing = true;
 	ui.sbValuesRotation->setValue(angle);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbValuesOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesPrefixChanged(const QString& prefix) {
 	m_initializing = true;
 	ui.leValuesPrefix->setText(prefix);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesSuffixChanged(const QString& suffix) {
 	m_initializing = true;
 	ui.leValuesSuffix->setText(suffix);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesFontChanged(QFont font) {
 	m_initializing = true;
 	font.setPointSizeF( round(Worksheet::convertFromSceneUnits(font.pixelSize(), Worksheet::Point)) );
 	ui.kfrValuesFont->setFont(font);
 	m_initializing = false;
 }
 void XYCurveDock::curveValuesColorChanged(QColor color) {
 	m_initializing = true;
 	ui.kcbValuesColor->setColor(color);
 	m_initializing = false;
 }
 
 //Filling
 void XYCurveDock::curveFillingPositionChanged(XYCurve::FillingPosition position) {
 	m_initializing = true;
 	ui.cbFillingPosition->setCurrentIndex((int)position);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingTypeChanged(PlotArea::BackgroundType type) {
 	m_initializing = true;
 	ui.cbFillingType->setCurrentIndex(type);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingColorStyleChanged(PlotArea::BackgroundColorStyle style) {
 	m_initializing = true;
 	ui.cbFillingColorStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingImageStyleChanged(PlotArea::BackgroundImageStyle style) {
 	m_initializing = true;
 	ui.cbFillingImageStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingBrushStyleChanged(Qt::BrushStyle style) {
 	m_initializing = true;
 	ui.cbFillingBrushStyle->setCurrentIndex(style);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingFirstColorChanged(QColor& color) {
 	m_initializing = true;
 	ui.kcbFillingFirstColor->setColor(color);
 	GuiTools::updateBrushStyles(ui.cbFillingBrushStyle, color);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingSecondColorChanged(QColor& color) {
 	m_initializing = true;
 	ui.kcbFillingSecondColor->setColor(color);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingFileNameChanged(QString& filename) {
 	m_initializing = true;
 	ui.leFillingFileName->setText(filename);
 	m_initializing = false;
 }
 void XYCurveDock::curveFillingOpacityChanged(float opacity) {
 	m_initializing = true;
 	ui.sbFillingOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //"Error bars"-Tab
 void XYCurveDock::curveXErrorTypeChanged(XYCurve::ErrorType type) {
 	m_initializing = true;
 	ui.cbXErrorType->setCurrentIndex((int) type);
 	m_initializing = false;
 }
 void XYCurveDock::curveXErrorPlusColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbXErrorPlusColumn, column);
 	m_initializing = false;
 }
 void XYCurveDock::curveXErrorMinusColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbXErrorMinusColumn, column);
 	m_initializing = false;
 }
 void XYCurveDock::curveYErrorTypeChanged(XYCurve::ErrorType type) {
 	m_initializing = true;
 	ui.cbYErrorType->setCurrentIndex((int) type);
 	m_initializing = false;
 }
 void XYCurveDock::curveYErrorPlusColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbYErrorPlusColumn, column);
 	m_initializing = false;
 }
 
 void XYCurveDock::curveYErrorMinusColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	this->setModelIndexFromAspect(cbYErrorMinusColumn, column);
 	m_initializing = false;
 }
 void XYCurveDock::curveErrorBarsCapSizeChanged(qreal size) {
 	m_initializing = true;
 	ui.sbErrorBarsCapSize->setValue( Worksheet::convertFromSceneUnits(size, Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveErrorBarsTypeChanged(XYCurve::ErrorBarsType type) {
 	m_initializing = true;
 	ui.cbErrorBarsType->setCurrentIndex( (int) type);
 	m_initializing = false;
 }
 void XYCurveDock::curveErrorBarsPenChanged(const QPen& pen) {
 	m_initializing = true;
 	ui.cbErrorBarsStyle->setCurrentIndex( (int) pen.style());
 	ui.kcbErrorBarsColor->setColor( pen.color());
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, pen.color());
 	ui.sbErrorBarsWidth->setValue( Worksheet::convertFromSceneUnits(pen.widthF(),Worksheet::Point) );
 	m_initializing = false;
 }
 void XYCurveDock::curveErrorBarsOpacityChanged(qreal opacity) {
 	m_initializing = true;
 	ui.sbErrorBarsOpacity->setValue( round(opacity*100.0) );
 	m_initializing = false;
 }
 
 //*************************************************************
 //************************* Settings **************************
 //*************************************************************
 void XYCurveDock::load() {
 	//General
 	//This data is read in XYCurveDock::setCurves().
 
 	//Line
 	ui.cbLineType->setCurrentIndex( (int) m_curve->lineType() );
 	ui.chkLineSkipGaps->setChecked( m_curve->lineSkipGaps() );
 	ui.sbLineInterpolationPointsCount->setValue( m_curve->lineInterpolationPointsCount() );
 	ui.cbLineStyle->setCurrentIndex( (int) m_curve->linePen().style() );
 	ui.kcbLineColor->setColor( m_curve->linePen().color() );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(m_curve->linePen().widthF(), Worksheet::Point) );
 	ui.sbLineOpacity->setValue( round(m_curve->lineOpacity()*100.0) );
 
 	//Drop lines
 	ui.cbDropLineType->setCurrentIndex( (int) m_curve->dropLineType() );
 	ui.cbDropLineStyle->setCurrentIndex( (int) m_curve->dropLinePen().style() );
 	ui.kcbDropLineColor->setColor( m_curve->dropLinePen().color() );
 	ui.sbDropLineWidth->setValue( Worksheet::convertFromSceneUnits(m_curve->dropLinePen().widthF(),Worksheet::Point) );
 	ui.sbDropLineOpacity->setValue( round(m_curve->dropLineOpacity()*100.0) );
 
 	//Symbols
 	ui.cbSymbolStyle->setCurrentIndex( (int)m_curve->symbolsStyle() );
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(m_curve->symbolsSize(), Worksheet::Point) );
 	ui.sbSymbolRotation->setValue( m_curve->symbolsRotationAngle() );
 	ui.sbSymbolOpacity->setValue( round(m_curve->symbolsOpacity()*100.0) );
 	ui.cbSymbolFillingStyle->setCurrentIndex( (int) m_curve->symbolsBrush().style() );
 	ui.kcbSymbolFillingColor->setColor(  m_curve->symbolsBrush().color() );
 	ui.cbSymbolBorderStyle->setCurrentIndex( (int) m_curve->symbolsPen().style() );
 	ui.kcbSymbolBorderColor->setColor( m_curve->symbolsPen().color() );
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(m_curve->symbolsPen().widthF(), Worksheet::Point) );
 
 	//Values
 	ui.cbValuesType->setCurrentIndex( (int) m_curve->valuesType() );
 	ui.cbValuesPosition->setCurrentIndex( (int) m_curve->valuesPosition() );
 	ui.sbValuesDistance->setValue( Worksheet::convertFromSceneUnits(m_curve->valuesDistance(), Worksheet::Point) );
 	ui.sbValuesRotation->setValue( m_curve->valuesRotationAngle() );
 	ui.sbValuesOpacity->setValue( round(m_curve->valuesOpacity()*100.0) );
 	ui.leValuesPrefix->setText( m_curve->valuesPrefix() );
 	ui.leValuesSuffix->setText( m_curve->valuesSuffix() );
 	QFont valuesFont = m_curve->valuesFont();
 	valuesFont.setPointSizeF( round(Worksheet::convertFromSceneUnits(valuesFont.pixelSize(), Worksheet::Point)) );
 	ui.kfrValuesFont->setFont(valuesFont);
 	ui.kcbValuesColor->setColor( m_curve->valuesColor() );
 
 	//Filling
 	ui.cbFillingPosition->setCurrentIndex( (int) m_curve->fillingPosition() );
 	ui.cbFillingType->setCurrentIndex( (int)m_curve->fillingType() );
 	ui.cbFillingColorStyle->setCurrentIndex( (int) m_curve->fillingColorStyle() );
 	ui.cbFillingImageStyle->setCurrentIndex( (int) m_curve->fillingImageStyle() );
 	ui.cbFillingBrushStyle->setCurrentIndex( (int) m_curve->fillingBrushStyle() );
 	ui.leFillingFileName->setText( m_curve->fillingFileName() );
 	ui.kcbFillingFirstColor->setColor( m_curve->fillingFirstColor() );
 	ui.kcbFillingSecondColor->setColor( m_curve->fillingSecondColor() );
 	ui.sbFillingOpacity->setValue( round(m_curve->fillingOpacity()*100.0) );
 
 	//Error bars
 	ui.cbXErrorType->setCurrentIndex( (int) m_curve->xErrorType() );
 	ui.cbYErrorType->setCurrentIndex( (int) m_curve->yErrorType() );
 	ui.cbErrorBarsType->setCurrentIndex( (int) m_curve->errorBarsType() );
 	ui.sbErrorBarsCapSize->setValue( Worksheet::convertFromSceneUnits(m_curve->errorBarsCapSize(), Worksheet::Point) );
 	ui.cbErrorBarsStyle->setCurrentIndex( (int) m_curve->errorBarsPen().style() );
 	ui.kcbErrorBarsColor->setColor( m_curve->errorBarsPen().color() );
 	ui.sbErrorBarsWidth->setValue( Worksheet::convertFromSceneUnits(m_curve->errorBarsPen().widthF(),Worksheet::Point) );
 	ui.sbErrorBarsOpacity->setValue( round(m_curve->errorBarsOpacity()*100.0) );
 
 	m_initializing=true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, ui.kcbLineColor->color());
 	GuiTools::updatePenStyles(ui.cbDropLineStyle, ui.kcbDropLineColor->color());
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, ui.kcbSymbolFillingColor->color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, ui.kcbSymbolBorderColor->color());
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, ui.kcbErrorBarsColor->color());
 	m_initializing=false;
 }
 
 void XYCurveDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	int index = config.name().lastIndexOf(QDir::separator());
 	if (index!=-1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	int size = m_curvesList.size();
 	if (size>1)
 		m_curve->beginMacro(i18n("%1 xy-curves: template \"%2\" loaded", size, name));
 	else
 		m_curve->beginMacro(i18n("%1: template \"%2\" loaded", m_curve->name(), name));
 
 	this->loadConfig(config);
 
 	m_curve->endMacro();
 }
 
 void XYCurveDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group( "XYCurve" );
 
 	//General
 	//we don't load/save the settings in the general-tab, since they are not style related.
 	//It doesn't make sense to load/save them in the template.
 	//This data is read in XYCurveDock::setCurves().
 
 	//Line
 	ui.cbLineType->setCurrentIndex( group.readEntry("LineType", (int) m_curve->lineType()) );
 	ui.chkLineSkipGaps->setChecked( group.readEntry("LineSkipGaps", m_curve->lineSkipGaps()) );
 	ui.sbLineInterpolationPointsCount->setValue( group.readEntry("LineInterpolationPointsCount", m_curve->lineInterpolationPointsCount()) );
 	ui.cbLineStyle->setCurrentIndex( group.readEntry("LineStyle", (int) m_curve->linePen().style()) );
 	ui.kcbLineColor->setColor( group.readEntry("LineColor", m_curve->linePen().color()) );
 	ui.sbLineWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("LineWidth", m_curve->linePen().widthF()), Worksheet::Point) );
 	ui.sbLineOpacity->setValue( round(group.readEntry("LineOpacity", m_curve->lineOpacity())*100.0) );
 
 	//Drop lines
 	ui.cbDropLineType->setCurrentIndex( group.readEntry("DropLineType", (int) m_curve->dropLineType()) );
 	ui.cbDropLineStyle->setCurrentIndex( group.readEntry("DropLineStyle", (int) m_curve->dropLinePen().style()) );
 	ui.kcbDropLineColor->setColor( group.readEntry("DropLineColor", m_curve->dropLinePen().color()) );
 	ui.sbDropLineWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("DropLineWidth", m_curve->dropLinePen().widthF()),Worksheet::Point) );
 	ui.sbDropLineOpacity->setValue( round(group.readEntry("DropLineOpacity", m_curve->dropLineOpacity())*100.0) );
 
 	//Symbols
 	ui.cbSymbolStyle->setCurrentIndex( group.readEntry("SymbolStyle", (int)m_curve->symbolsStyle()) );
 	ui.sbSymbolSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolSize", m_curve->symbolsSize()), Worksheet::Point) );
 	ui.sbSymbolRotation->setValue( group.readEntry("SymbolRotation", m_curve->symbolsRotationAngle()) );
 	ui.sbSymbolOpacity->setValue( round(group.readEntry("SymbolOpacity", m_curve->symbolsOpacity())*100.0) );
 	ui.cbSymbolFillingStyle->setCurrentIndex( group.readEntry("SymbolFillingStyle", (int) m_curve->symbolsBrush().style()) );
 	ui.kcbSymbolFillingColor->setColor(  group.readEntry("SymbolFillingColor", m_curve->symbolsBrush().color()) );
 	ui.cbSymbolBorderStyle->setCurrentIndex( group.readEntry("SymbolBorderStyle", (int) m_curve->symbolsPen().style()) );
 	ui.kcbSymbolBorderColor->setColor( group.readEntry("SymbolBorderColor", m_curve->symbolsPen().color()) );
 	ui.sbSymbolBorderWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("SymbolBorderWidth",m_curve->symbolsPen().widthF()), Worksheet::Point) );
 
 	//Values
 	ui.cbValuesType->setCurrentIndex( group.readEntry("ValuesType", (int) m_curve->valuesType()) );
 	ui.cbValuesPosition->setCurrentIndex( group.readEntry("ValuesPosition", (int) m_curve->valuesPosition()) );
 	ui.sbValuesDistance->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ValuesDistance", m_curve->valuesDistance()), Worksheet::Point) );
 	ui.sbValuesRotation->setValue( group.readEntry("ValuesRotation", m_curve->valuesRotationAngle()) );
 	ui.sbValuesOpacity->setValue( round(group.readEntry("ValuesOpacity",m_curve->valuesOpacity())*100.0) );
 	ui.leValuesPrefix->setText( group.readEntry("ValuesPrefix", m_curve->valuesPrefix()) );
 	ui.leValuesSuffix->setText( group.readEntry("ValuesSuffix", m_curve->valuesSuffix()) );
 	QFont valuesFont = m_curve->valuesFont();
 	valuesFont.setPointSizeF( round(Worksheet::convertFromSceneUnits(valuesFont.pixelSize(), Worksheet::Point)) );
 	ui.kfrValuesFont->setFont( group.readEntry("ValuesFont", valuesFont) );
 	ui.kcbValuesColor->setColor( group.readEntry("ValuesColor", m_curve->valuesColor()) );
 
 	//Filling
 	ui.cbFillingPosition->setCurrentIndex( group.readEntry("FillingPosition", (int) m_curve->fillingPosition()) );
 	ui.cbFillingType->setCurrentIndex( group.readEntry("FillingType", (int) m_curve->fillingType()) );
 	ui.cbFillingColorStyle->setCurrentIndex( group.readEntry("FillingColorStyle", (int) m_curve->fillingColorStyle()) );
 	ui.cbFillingImageStyle->setCurrentIndex( group.readEntry("FillingImageStyle", (int) m_curve->fillingImageStyle()) );
 	ui.cbFillingBrushStyle->setCurrentIndex( group.readEntry("FillingBrushStyle", (int) m_curve->fillingBrushStyle()) );
 	ui.leFillingFileName->setText( group.readEntry("FillingFileName", m_curve->fillingFileName()) );
 	ui.kcbFillingFirstColor->setColor( group.readEntry("FillingFirstColor", m_curve->fillingFirstColor()) );
 	ui.kcbFillingSecondColor->setColor( group.readEntry("FillingSecondColor", m_curve->fillingSecondColor()) );
 	ui.sbFillingOpacity->setValue( round(group.readEntry("FillingOpacity", m_curve->fillingOpacity())*100.0) );
 
 	//Error bars
 	ui.cbXErrorType->setCurrentIndex( group.readEntry("XErrorType", (int) m_curve->xErrorType()) );
 	ui.cbYErrorType->setCurrentIndex( group.readEntry("YErrorType", (int) m_curve->yErrorType()) );
 	ui.cbErrorBarsType->setCurrentIndex( group.readEntry("ErrorBarsType", (int) m_curve->errorBarsType()) );
 	ui.sbErrorBarsCapSize->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ErrorBarsCapSize", m_curve->errorBarsCapSize()), Worksheet::Point) );
 	ui.cbErrorBarsStyle->setCurrentIndex( group.readEntry("ErrorBarsStyle", (int) m_curve->errorBarsPen().style()) );
 	ui.kcbErrorBarsColor->setColor( group.readEntry("ErrorBarsColor", m_curve->errorBarsPen().color()) );
 	ui.sbErrorBarsWidth->setValue( Worksheet::convertFromSceneUnits(group.readEntry("ErrorBarsWidth", m_curve->errorBarsPen().widthF()),Worksheet::Point) );
 	ui.sbErrorBarsOpacity->setValue( round(group.readEntry("ErrorBarsOpacity", m_curve->errorBarsOpacity())*100.0) );
 
 	m_initializing=true;
 	GuiTools::updatePenStyles(ui.cbLineStyle, ui.kcbLineColor->color());
 	GuiTools::updatePenStyles(ui.cbDropLineStyle, ui.kcbDropLineColor->color());
 	GuiTools::updateBrushStyles(ui.cbSymbolFillingStyle, ui.kcbSymbolFillingColor->color());
 	GuiTools::updatePenStyles(ui.cbSymbolBorderStyle, ui.kcbSymbolBorderColor->color());
 	GuiTools::updatePenStyles(ui.cbErrorBarsStyle, ui.kcbErrorBarsColor->color());
 	GuiTools::updateBrushStyles(ui.cbFillingBrushStyle, ui.kcbFillingFirstColor->color());
 	m_initializing=false;
 }
 
 void XYCurveDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "XYCurve" );
 
 	//General
 	//we don't load/save the settings in the general-tab, since they are not style related.
 	//It doesn't make sense to load/save them in the template.
 
 	group.writeEntry("LineType", ui.cbLineType->currentIndex());
 	group.writeEntry("LineSkipGaps", ui.chkLineSkipGaps->isChecked());
 	group.writeEntry("LineInterpolationPointsCount", ui.sbLineInterpolationPointsCount->value() );
 	group.writeEntry("LineStyle", ui.cbLineStyle->currentIndex());
 	group.writeEntry("LineColor", ui.kcbLineColor->color());
 	group.writeEntry("LineWidth", Worksheet::convertToSceneUnits(ui.sbLineWidth->value(),Worksheet::Point) );
 	group.writeEntry("LineOpacity", ui.sbLineOpacity->value()/100 );
 
 	//Drop Line
 	group.writeEntry("DropLineType", ui.cbDropLineType->currentIndex());
 	group.writeEntry("DropLineStyle", ui.cbDropLineStyle->currentIndex());
 	group.writeEntry("DropLineColor", ui.kcbDropLineColor->color());
 	group.writeEntry("DropLineWidth", Worksheet::convertToSceneUnits(ui.sbDropLineWidth->value(),Worksheet::Point) );
 	group.writeEntry("DropLineOpacity", ui.sbDropLineOpacity->value()/100 );
 
 	//Symbol (TODO: character)
 	group.writeEntry("SymbolStyle", ui.cbSymbolStyle->currentIndex());
 	group.writeEntry("SymbolSize", Worksheet::convertToSceneUnits(ui.sbSymbolSize->value(),Worksheet::Point));
 	group.writeEntry("SymbolRotation", ui.sbSymbolRotation->value());
 	group.writeEntry("SymbolOpacity", ui.sbSymbolOpacity->value()/100 );
 	group.writeEntry("SymbolFillingStyle", ui.cbSymbolFillingStyle->currentIndex());
 	group.writeEntry("SymbolFillingColor", ui.kcbSymbolFillingColor->color());
 	group.writeEntry("SymbolBorderStyle", ui.cbSymbolBorderStyle->currentIndex());
 	group.writeEntry("SymbolBorderColor", ui.kcbSymbolBorderColor->color());
 	group.writeEntry("SymbolBorderWidth", Worksheet::convertToSceneUnits(ui.sbSymbolBorderWidth->value(),Worksheet::Point));
 
 	//Values
 	group.writeEntry("ValuesType", ui.cbValuesType->currentIndex());
 	group.writeEntry("ValuesPosition", ui.cbValuesPosition->currentIndex());
 	group.writeEntry("ValuesDistance", Worksheet::convertToSceneUnits(ui.sbValuesDistance->value(),Worksheet::Point));
 	group.writeEntry("ValuesRotation", ui.sbValuesRotation->value());
 	group.writeEntry("ValuesOpacity", ui.sbValuesOpacity->value()/100);
 	group.writeEntry("ValuesPrefix", ui.leValuesPrefix->text());
 	group.writeEntry("ValuesSuffix", ui.leValuesSuffix->text());
 	group.writeEntry("ValuesFont", ui.kfrValuesFont->font());
 	group.writeEntry("ValuesColor", ui.kcbValuesColor->color());
 
 	//Filling
 	group.writeEntry("FillingPosition", ui.cbFillingPosition->currentIndex());
 	group.writeEntry("FillingType", ui.cbFillingType->currentIndex());
 	group.writeEntry("FillingColorStyle", ui.cbFillingColorStyle->currentIndex());
 	group.writeEntry("FillingImageStyle", ui.cbFillingImageStyle->currentIndex());
 	group.writeEntry("FillingBrushStyle", ui.cbFillingBrushStyle->currentIndex());
 	group.writeEntry("FillingFileName", ui.leFillingFileName->text());
 	group.writeEntry("FillingFirstColor", ui.kcbFillingFirstColor->color());
 	group.writeEntry("FillingSecondColor", ui.kcbFillingSecondColor->color());
 	group.writeEntry("FillingOpacity", ui.sbFillingOpacity->value()/100.0);
 
 	//Error bars
 	group.writeEntry("XErrorType", ui.cbXErrorType->currentIndex());
 	group.writeEntry("YErrorType", ui.cbYErrorType->currentIndex());
 	group.writeEntry("ErrorBarsType", ui.cbErrorBarsType->currentIndex());
 	group.writeEntry("ErrorBarsCapSize", Worksheet::convertToSceneUnits(ui.sbErrorBarsCapSize->value(),Worksheet::Point) );
 	group.writeEntry("ErrorBarsStyle", ui.cbErrorBarsStyle->currentIndex());
 	group.writeEntry("ErrorBarsColor", ui.kcbErrorBarsColor->color());
 	group.writeEntry("ErrorBarsWidth", Worksheet::convertToSceneUnits(ui.sbErrorBarsWidth->value(),Worksheet::Point) );
 	group.writeEntry("ErrorBarsOpacity", ui.sbErrorBarsOpacity->value()/100 );
 
 	config.sync();
 }
diff --git a/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp b/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
index f8bf1c613..5aa14c3c8 100644
--- a/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYDataReductionCurveDock.cpp
@@ -1,698 +1,698 @@
 /***************************************************************************
     File             : XYDataReductionCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of data reduction curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYDataReductionCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYDataReductionCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 #include <QStatusBar>
 #include <QProgressBar>
 
 /*!
   \class XYDataReductionCurveDock
  \brief  Provides a widget for editing the properties of the XYDataReductionCurves
 		(2D-curves defined by an data reduction) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYDataReductionCurveDock::XYDataReductionCurveDock(QWidget* parent, QStatusBar* sb) : XYCurveDock(parent),
 	statusBar(sb),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_dataReductionCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYDataReductionCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
-	auto gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 3);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 3);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 3);
 
-	for (int i=0; i < NSL_GEOM_LINESIM_TYPE_COUNT; ++i)
+	for (int i = 0; i < NSL_GEOM_LINESIM_TYPE_COUNT; ++i)
 		uiGeneralTab.cbType->addItem(i18n(nsl_geom_linesim_type_name[i]));
 	uiGeneralTab.cbType->setItemData(nsl_geom_linesim_type_visvalingam_whyatt, i18n("This method is much slower than any other"), Qt::ToolTipRole);
 
 	uiGeneralTab.sbMin->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbMax->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbTolerance->setRange(0.0, std::numeric_limits<double>::max());
 	uiGeneralTab.sbTolerance2->setRange(0.0, std::numeric_limits<double>::max());
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYDataReductionCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYDataReductionCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.chkAuto, SIGNAL(clicked(bool)), this, SLOT(autoToleranceChanged()) );
 	connect( uiGeneralTab.sbTolerance, SIGNAL(valueChanged(double)), this, SLOT(toleranceChanged()) );
 	connect( uiGeneralTab.chkAuto2, SIGNAL(clicked(bool)), this, SLOT(autoTolerance2Changed()) );
 	connect( uiGeneralTab.sbTolerance2, SIGNAL(valueChanged(double)), this, SLOT(tolerance2Changed()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYDataReductionCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size() == 1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	} else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_dataReductionCurve = dynamic_cast<XYDataReductionCurve*>(m_curve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_dataReductionCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_dataReductionCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_dataReductionCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_dataReductionCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_dataReductionData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_dataReductionData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_dataReductionData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbType->setCurrentIndex(m_dataReductionData.type);
 	this->typeChanged();
 	uiGeneralTab.chkAuto->setChecked(m_dataReductionData.autoTolerance);
 	this->autoToleranceChanged();
 	uiGeneralTab.sbTolerance->setValue(m_dataReductionData.tolerance);
 	this->toleranceChanged();
 	uiGeneralTab.chkAuto2->setChecked(m_dataReductionData.autoTolerance2);
 	this->autoTolerance2Changed();
 	uiGeneralTab.sbTolerance2->setValue(m_dataReductionData.tolerance2);
 	this->tolerance2Changed();
 
 	this->showDataReductionResult();
 
 	//enable the "recalculate"-button if the source data was changed since the last dataReduction
 	uiGeneralTab.pbRecalculate->setEnabled(m_dataReductionCurve->isSourceDataChangedSinceLastRecalc());
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_dataReductionCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_dataReductionCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_dataReductionCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_dataReductionCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_dataReductionCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_dataReductionCurve, SIGNAL(dataReductionDataChanged(XYDataReductionCurve::DataReductionData)), this, SLOT(curveDataReductionDataChanged(XYDataReductionCurve::DataReductionData)));
 	connect(m_dataReductionCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYDataReductionCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve : m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 	    <<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYDataReductionCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_dataReductionCurve = dynamic_cast<XYDataReductionCurve*>(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_dataReductionData = m_dataReductionCurve->dataReductionData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYDataReductionCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYDataReductionCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYDataReductionCurveDock::dataSourceTypeChanged(int index) {
 	const auto type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYDataReductionCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 
 // 	// disable deriv orders and accuracies that need more data points
 // 	this->updateSettings(dataSourceCurve->xColumn());
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYDataReductionCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setXDataColumn(column);
 
 	//TODO: this->updateSettings(column); ?
 	if (column != nullptr && uiGeneralTab.cbAutoRange->isChecked()) {
 		uiGeneralTab.sbMin->setValue(column->minimum());
 		uiGeneralTab.sbMax->setValue(column->maximum());
 	}
 
 	updateTolerance();
 	updateTolerance2();
 }
 
 void XYDataReductionCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setYDataColumn(column);
 
 	updateTolerance();
 	updateTolerance2();
 }
 
 void XYDataReductionCurveDock::updateTolerance() {
 	const AbstractColumn* xDataColumn = nullptr;
 	const AbstractColumn* yDataColumn = nullptr;
 	if (m_dataReductionCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		xDataColumn = m_dataReductionCurve->xDataColumn();
 		yDataColumn = m_dataReductionCurve->yDataColumn();
 	} else {
 		if (m_dataReductionCurve->dataSourceCurve()) {
 			xDataColumn = m_dataReductionCurve->dataSourceCurve()->xColumn();
 			yDataColumn = m_dataReductionCurve->dataSourceCurve()->yColumn();
 		}
 	}
 
 	if(xDataColumn == nullptr || yDataColumn == nullptr)
 		return;
 
 	//copy all valid data points for calculating tolerance to temporary vectors
 	QVector<double> xdataVector;
 	QVector<double> ydataVector;
 	const double xmin = m_dataReductionData.xRange.first();
 	const double xmax = m_dataReductionData.xRange.last();
 	for (int row=0; row<xDataColumn->rowCount(); ++row) {
 		//only copy those data where _all_ values (for x and y, if given) are valid
 		if (!std::isnan(xDataColumn->valueAt(row)) && !std::isnan(yDataColumn->valueAt(row))
 		        && !xDataColumn->isMasked(row) && !yDataColumn->isMasked(row)) {
 			// only when inside given range
 			if (xDataColumn->valueAt(row) >= xmin && xDataColumn->valueAt(row) <= xmax) {
 				xdataVector.append(xDataColumn->valueAt(row));
 				ydataVector.append(yDataColumn->valueAt(row));
 			}
 		}
 	}
 
 	if(xdataVector.size() > 1)
 		uiGeneralTab.cbType->setEnabled(true);
 	else {
 		uiGeneralTab.cbType->setEnabled(false);
 		return;
 	}
 	DEBUG("automatic tolerance:");
 	DEBUG("clip_diag_perpoint =" << nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size()));
 	DEBUG("clip_area_perpoint =" << nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size()));
 	DEBUG("avg_dist_perpoint =" << nsl_geom_linesim_avg_dist_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size()));
 
 	const auto type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 	if (type == nsl_geom_linesim_type_raddist || type == nsl_geom_linesim_type_opheim)
 		m_dataReductionData.tolerance = 10. * nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
 	else if (type == nsl_geom_linesim_type_visvalingam_whyatt)
 		m_dataReductionData.tolerance = 0.1 * nsl_geom_linesim_clip_area_perpoint(xdataVector.data(), ydataVector.data(), (size_t)xdataVector.size());
 	else if (type == nsl_geom_linesim_type_douglas_peucker_variant)
 		m_dataReductionData.tolerance = xdataVector.size()/10.;	// reduction to 10%
 	else
 		m_dataReductionData.tolerance = 2.*nsl_geom_linesim_avg_dist_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
 	//m_dataReductionData.tolerance = nsl_geom_linesim_clip_diag_perpoint(xdataVector.data(), ydataVector.data(), xdataVector.size());
 	uiGeneralTab.sbTolerance->setValue(m_dataReductionData.tolerance);
 }
 
 void XYDataReductionCurveDock::updateTolerance2() {
 	const auto type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 
 	if (type == nsl_geom_linesim_type_perpdist)
 		uiGeneralTab.sbTolerance2->setValue(10);
 	else if (type == nsl_geom_linesim_type_opheim)
 		uiGeneralTab.sbTolerance2->setValue(5*uiGeneralTab.sbTolerance->value());
 	else if (type == nsl_geom_linesim_type_lang)
 		uiGeneralTab.sbTolerance2->setValue(10);
 }
 
 void XYDataReductionCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_dataReductionData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = nullptr;
 		if (m_dataReductionCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet)
 			xDataColumn = m_dataReductionCurve->xDataColumn();
 		else {
 			if (m_dataReductionCurve->dataSourceCurve())
 				xDataColumn = m_dataReductionCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYDataReductionCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_dataReductionData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_dataReductionData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::typeChanged() {
 	const auto type = (nsl_geom_linesim_type)uiGeneralTab.cbType->currentIndex();
 	m_dataReductionData.type = type;
 
 	switch (type) {
 	case nsl_geom_linesim_type_douglas_peucker:
 	case nsl_geom_linesim_type_raddist:
 	case nsl_geom_linesim_type_interp:
 	case nsl_geom_linesim_type_reumann_witkam:
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance):"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_douglas_peucker_variant:
 		uiGeneralTab.lOption->setText(i18n("Number of points:"));
 		uiGeneralTab.sbTolerance->setDecimals(0);
 		uiGeneralTab.sbTolerance->setMinimum(2);
 		uiGeneralTab.sbTolerance->setSingleStep(1);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_nthpoint:
 		uiGeneralTab.lOption->setText(i18n("Step size:"));
 		uiGeneralTab.sbTolerance->setValue(10);
 		uiGeneralTab.sbTolerance->setDecimals(0);
 		uiGeneralTab.sbTolerance->setMinimum(1);
 		uiGeneralTab.sbTolerance->setSingleStep(1);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		break;
 	case nsl_geom_linesim_type_perpdist:	// repeat option
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance):"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.lOption2->setText(i18n("Repeats:"));
 		uiGeneralTab.sbTolerance2->setDecimals(0);
 		uiGeneralTab.sbTolerance2->setMinimum(1);
 		uiGeneralTab.sbTolerance2->setSingleStep(1);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	case nsl_geom_linesim_type_visvalingam_whyatt:
 		uiGeneralTab.lOption->setText(i18n("Tolerance (area):"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->hide();
 		uiGeneralTab.chkAuto2->hide();
 		uiGeneralTab.sbTolerance2->hide();
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		break;
 	case nsl_geom_linesim_type_opheim:	// min/max tol options
 		uiGeneralTab.lOption->setText(i18n("Minimum tolerance:"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->setText(i18n("Maximum tolerance:"));
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.sbTolerance2->setDecimals(6);
 		uiGeneralTab.sbTolerance2->setMinimum(0);
 		uiGeneralTab.sbTolerance2->setSingleStep(0.01);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	case nsl_geom_linesim_type_lang:	// distance/region
 		uiGeneralTab.lOption->setText(i18n("Tolerance (distance):"));
 		uiGeneralTab.sbTolerance->setDecimals(6);
 		uiGeneralTab.sbTolerance->setMinimum(0);
 		uiGeneralTab.sbTolerance->setSingleStep(0.01);
 		uiGeneralTab.lOption2->setText(i18n("Search region:"));
 		uiGeneralTab.lOption2->show();
 		uiGeneralTab.chkAuto2->show();
 		uiGeneralTab.sbTolerance2->show();
 		uiGeneralTab.sbTolerance2->setDecimals(0);
 		uiGeneralTab.sbTolerance2->setMinimum(1);
 		uiGeneralTab.sbTolerance2->setSingleStep(1);
 		if (uiGeneralTab.chkAuto->isChecked())
 			updateTolerance();
 		if (uiGeneralTab.chkAuto2->isChecked())
 			updateTolerance2();
 		break;
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::autoToleranceChanged() {
 	const auto autoTolerance = (bool)uiGeneralTab.chkAuto->isChecked();
 	m_dataReductionData.autoTolerance = autoTolerance;
 
 	if (autoTolerance) {
 		uiGeneralTab.sbTolerance->setEnabled(false);
 		updateTolerance();
 	} else
 		uiGeneralTab.sbTolerance->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::toleranceChanged() {
 	m_dataReductionData.tolerance = uiGeneralTab.sbTolerance->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::autoTolerance2Changed() {
 	const auto autoTolerance2 = (bool)uiGeneralTab.chkAuto2->isChecked();
 	m_dataReductionData.autoTolerance2 = autoTolerance2;
 
 	if (autoTolerance2) {
 		uiGeneralTab.sbTolerance2->setEnabled(false);
 		updateTolerance2();
 	} else
 		uiGeneralTab.sbTolerance2->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::tolerance2Changed() {
 	m_dataReductionData.tolerance2 = uiGeneralTab.sbTolerance2->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDataReductionCurveDock::recalculateClicked() {
 	//show a progress bar in the status bar
-	auto progressBar = new QProgressBar();
+	auto* progressBar = new QProgressBar();
 	progressBar->setMinimum(0);
 	progressBar->setMaximum(100);
 	connect(m_curve, SIGNAL(completed(int)), progressBar, SLOT(setValue(int)));
 	statusBar->clearMessage();
 	statusBar->addWidget(progressBar, 1);
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDataReductionCurve*>(curve)->setDataReductionData(m_dataReductionData);
 
 	QApplication::restoreOverrideCursor();
 	statusBar->removeWidget(progressBar);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Data reduction status: %1", m_dataReductionCurve->dataReductionResult().status));
 }
 
 void XYDataReductionCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no dataReductioning possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_dataReductionCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=nullptr && aspectY!=nullptr);
 	} else {
 		 hasSourceData = (m_dataReductionCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the dataReduction
  */
 void XYDataReductionCurveDock::showDataReductionResult() {
 	const XYDataReductionCurve::DataReductionResult& dataReductionResult = m_dataReductionCurve->dataReductionResult();
 	if (!dataReductionResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status: %1", dataReductionResult.status) + "<br>";
 
 	if (!dataReductionResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (dataReductionResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s", QString::number(dataReductionResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms", QString::number(dataReductionResult.elapsedTime)) + "<br>";
 
 	str += "<br>";
 
 	str += i18n("number of points: %1", QString::number(dataReductionResult.npoints)) + "<br>";
 	str += i18n("positional squared error: %1", QString::number(dataReductionResult.posError)) + "<br>";
 	str += i18n("area error: %1", QString::number(dataReductionResult.areaError)) + "<br>";
 
 	uiGeneralTab.teResult->setText(str);
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYDataReductionCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::curveDataReductionDataChanged(const XYDataReductionCurve::DataReductionData& dataReductionData) {
 	m_initializing = true;
 	m_dataReductionData = dataReductionData;
 	//uiGeneralTab.cbType->setCurrentIndex(m_dataReductionData.type);
 	//this->typeChanged();
 
 	this->showDataReductionResult();
 	m_initializing = false;
 }
 
 void XYDataReductionCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYDifferentiationCurveDock.cpp b/src/kdefrontend/dockwidgets/XYDifferentiationCurveDock.cpp
index 25a9e17fa..6862ab311 100644
--- a/src/kdefrontend/dockwidgets/XYDifferentiationCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYDifferentiationCurveDock.cpp
@@ -1,589 +1,589 @@
 /***************************************************************************
     File             : XYDifferentiationCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of differentiation curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYDifferentiationCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYDifferentiationCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QStandardItemModel>
 
 extern "C" {
 #include "backend/nsl/nsl_diff.h"
 }
 
 /*!
   \class XYDifferentiationCurveDock
  \brief  Provides a widget for editing the properties of the XYDifferentiationCurves
 		(2D-curves defined by a differentiation) currently selected in
 		the project explorer.
 
   If more than one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYDifferentiationCurveDock::XYDifferentiationCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_differentiationCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYDifferentiationCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
-	auto gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 3);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 3);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 3);
 
-	for (int i=0; i < NSL_DIFF_DERIV_ORDER_COUNT; ++i)
+	for (int i = 0; i < NSL_DIFF_DERIV_ORDER_COUNT; ++i)
 		uiGeneralTab.cbDerivOrder->addItem(i18n(nsl_diff_deriv_order_name[i]));
 
 	uiGeneralTab.sbMin->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbMax->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 
 	uiGeneralTab.pbRecalculate->setIcon( QIcon::fromTheme("run-build") );
 
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYDifferentiationCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYDifferentiationCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbDerivOrder, SIGNAL(currentIndexChanged(int)), this, SLOT(derivOrderChanged()) );
 	connect( uiGeneralTab.sbAccOrder, SIGNAL(valueChanged(int)), this, SLOT(accOrderChanged()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYDifferentiationCurveDock::initGeneralTab() {
 	//if there are more than one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_differentiationCurve = dynamic_cast<XYDifferentiationCurve*>(m_curve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_differentiationCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_differentiationCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_differentiationCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_differentiationCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_differentiationData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_differentiationData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_differentiationData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbDerivOrder->setCurrentIndex(m_differentiationData.derivOrder);
 	this->derivOrderChanged();
 	uiGeneralTab.sbAccOrder->setValue(m_differentiationData.accOrder);
 	this->accOrderChanged();
 
 	this->showDifferentiationResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_differentiationCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_differentiationCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_differentiationCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_differentiationCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_differentiationCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_differentiationCurve, SIGNAL(differentiationDataChanged(XYDifferentiationCurve::DifferentiationData)), this, SLOT(curveDifferentiationDataChanged(XYDifferentiationCurve::DifferentiationData)));
 	connect(m_differentiationCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYDifferentiationCurveDock::setModel() {
-	QList<const char*>  list;
+	QList<const char*> list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
-	for (auto curve : m_curvesList)
+	for (auto* curve : m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYDifferentiationCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing = true;
 	m_curvesList = list;
 	m_curve = list.first();
 	m_differentiationCurve = dynamic_cast<XYDifferentiationCurve*>(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_differentiationData = m_differentiationCurve->differentiationData();
 	initGeneralTab();
 	initTabs();
 	m_initializing = false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYDifferentiationCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYDifferentiationCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYDifferentiationCurveDock::dataSourceTypeChanged(int index) {
 	const auto type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDifferentiationCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYDifferentiationCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 
 	// disable deriv orders and accuracies that need more data points
 	this->updateSettings(dataSourceCurve->xColumn());
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDifferentiationCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYDifferentiationCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	// disable deriv orders and accuracies that need more data points
 	this->updateSettings(column);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDifferentiationCurve*>(curve)->setXDataColumn(column);
 }
 
 void XYDifferentiationCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYDifferentiationCurve*>(curve)->setYDataColumn(column);
 }
 
 /*!
  * disable deriv orders and accuracies that need more data points
  */
 void XYDifferentiationCurveDock::updateSettings(const AbstractColumn* column) {
 	if (!column)
 		return;
 
 	if (uiGeneralTab.cbAutoRange->isChecked()) {
 		uiGeneralTab.sbMin->setValue(column->minimum());
 		uiGeneralTab.sbMax->setValue(column->maximum());
 	}
 
 	size_t n=0;
 	for (int row=0; row < column->rowCount(); ++row)
 		if (!std::isnan(column->valueAt(row)) && !column->isMasked(row))
 			n++;
 
-	const auto model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbDerivOrder->model());
+	const auto* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbDerivOrder->model());
 	QStandardItem* item = model->item(nsl_diff_deriv_order_first);
 	if (n < 3)
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 	else {
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 		if (n < 5)
 			uiGeneralTab.sbAccOrder->setMinimum(2);
 	}
 
 	item = model->item(nsl_diff_deriv_order_second);
 	if (n < 3) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbDerivOrder->currentIndex() == nsl_diff_deriv_order_second)
 				uiGeneralTab.cbDerivOrder->setCurrentIndex(nsl_diff_deriv_order_first);
 	}
 	else {
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 		if (n < 4)
 			uiGeneralTab.sbAccOrder->setMinimum(1);
 		else if (n < 5)
 			uiGeneralTab.sbAccOrder->setMinimum(2);
 	}
 
 	item = model->item(nsl_diff_deriv_order_third);
 	if (n < 5) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbDerivOrder->currentIndex() == nsl_diff_deriv_order_third)
 				uiGeneralTab.cbDerivOrder->setCurrentIndex(nsl_diff_deriv_order_first);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_diff_deriv_order_fourth);
 	if (n < 5) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbDerivOrder->currentIndex() == nsl_diff_deriv_order_fourth)
 				uiGeneralTab.cbDerivOrder->setCurrentIndex(nsl_diff_deriv_order_first);
 	}
 	else {
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 		if (n < 7)
 			uiGeneralTab.sbAccOrder->setMinimum(1);
 	}
 
 	item = model->item(nsl_diff_deriv_order_fifth);
 	if (n < 7) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbDerivOrder->currentIndex() == nsl_diff_deriv_order_fifth)
 				uiGeneralTab.cbDerivOrder->setCurrentIndex(nsl_diff_deriv_order_first);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_diff_deriv_order_sixth);
 	if (n < 7) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbDerivOrder->currentIndex() == nsl_diff_deriv_order_sixth)
 				uiGeneralTab.cbDerivOrder->setCurrentIndex(nsl_diff_deriv_order_first);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 }
 
 void XYDifferentiationCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_differentiationData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = nullptr;
 		if (m_differentiationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet)
 			xDataColumn = m_differentiationCurve->xDataColumn();
 		else {
 			if (m_differentiationCurve->dataSourceCurve())
 				xDataColumn = m_differentiationCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 }
 
 void XYDifferentiationCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_differentiationData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDifferentiationCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_differentiationData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDifferentiationCurveDock::derivOrderChanged() {
 	const auto derivOrder = (nsl_diff_deriv_order_type)uiGeneralTab.cbDerivOrder->currentIndex();
 	m_differentiationData.derivOrder = derivOrder;
 
 	// update avail. accuracies
 	switch (derivOrder) {
 	case nsl_diff_deriv_order_first:
 		uiGeneralTab.sbAccOrder->setMinimum(2);
 		uiGeneralTab.sbAccOrder->setMaximum(4);
 		uiGeneralTab.sbAccOrder->setSingleStep(2);
 		uiGeneralTab.sbAccOrder->setValue(4);
 		break;
 	case nsl_diff_deriv_order_second:
 		uiGeneralTab.sbAccOrder->setMinimum(1);
 		uiGeneralTab.sbAccOrder->setMaximum(3);
 		uiGeneralTab.sbAccOrder->setSingleStep(1);
 		uiGeneralTab.sbAccOrder->setValue(3);
 		break;
 	case nsl_diff_deriv_order_third:
 		uiGeneralTab.sbAccOrder->setMinimum(2);
 		uiGeneralTab.sbAccOrder->setMaximum(2);
 		break;
 	case nsl_diff_deriv_order_fourth:
 		uiGeneralTab.sbAccOrder->setMinimum(1);
 		uiGeneralTab.sbAccOrder->setMaximum(3);
 		uiGeneralTab.sbAccOrder->setSingleStep(2);
 		uiGeneralTab.sbAccOrder->setValue(3);
 		break;
 	case nsl_diff_deriv_order_fifth:
 		uiGeneralTab.sbAccOrder->setMinimum(2);
 		uiGeneralTab.sbAccOrder->setMaximum(2);
 		break;
 	case nsl_diff_deriv_order_sixth:
 		uiGeneralTab.sbAccOrder->setMinimum(1);
 		uiGeneralTab.sbAccOrder->setMaximum(1);
 		break;
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDifferentiationCurveDock::accOrderChanged() {
 	const auto accOrder = (int)uiGeneralTab.sbAccOrder->value();
 	m_differentiationData.accOrder = accOrder;
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYDifferentiationCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for (auto* curve : m_curvesList)
 		if (curve != nullptr)
 			dynamic_cast<XYDifferentiationCurve*>(curve)->setDifferentiationData(m_differentiationData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Differentiation status: %1", m_differentiationCurve->differentiationResult().status));
 	QApplication::restoreOverrideCursor();
 }
 
 void XYDifferentiationCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no differentiation possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_differentiationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=nullptr && aspectY!=nullptr);
 	} else {
 		 hasSourceData = (m_differentiationCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the differentiation
  */
 void XYDifferentiationCurveDock::showDifferentiationResult() {
 	const XYDifferentiationCurve::DifferentiationResult& differentiationResult = m_differentiationCurve->differentiationResult();
 	if (!differentiationResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status: %1", differentiationResult.status) + "<br>";
 
 	if (!differentiationResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (differentiationResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s", QString::number(differentiationResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms", QString::number(differentiationResult.elapsedTime)) + "<br>";
 
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last differentiation
 	uiGeneralTab.pbRecalculate->setEnabled(m_differentiationCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*** SLOTs for changes triggered in XYDifferentiationCurve ***
 //*************************************************************
 //General-Tab
 void XYDifferentiationCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::curveDifferentiationDataChanged(const XYDifferentiationCurve::DifferentiationData& differentiationData) {
 	m_initializing = true;
 	m_differentiationData = differentiationData;
 	uiGeneralTab.cbDerivOrder->setCurrentIndex(m_differentiationData.derivOrder);
 	this->derivOrderChanged();
 	uiGeneralTab.sbAccOrder->setValue(m_differentiationData.accOrder);
 	this->accOrderChanged();
 
 	this->showDifferentiationResult();
 	m_initializing = false;
 }
 
 void XYDifferentiationCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYEquationCurveDock.cpp b/src/kdefrontend/dockwidgets/XYEquationCurveDock.cpp
index 606bb5ceb..4bc7b4d37 100644
--- a/src/kdefrontend/dockwidgets/XYEquationCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYEquationCurveDock.cpp
@@ -1,378 +1,378 @@
 /***************************************************************************
     File             : XYEquationCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2014 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of equation curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYEquationCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYEquationCurve.h"
 #include "backend/gsl/ExpressionParser.h"
 #include "kdefrontend/widgets/ConstantsWidget.h"
 #include "kdefrontend/widgets/FunctionsWidget.h"
 
 #include <QCompleter>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QWidgetAction>
 
 #include <KLocalizedString>
 
 /*!
   \class XYEquationCurveDock
   \brief  Provides a widget for editing the properties of the XYEquationCurves
 		(2D-curves defined by a mathematical equation) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYEquationCurveDock::XYEquationCurveDock(QWidget *parent): XYCurveDock(parent), m_equationCurve(nullptr) {
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYEquationCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
-	auto gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	uiGeneralTab.tbConstants1->setIcon( QIcon::fromTheme("labplot-format-text-symbol") );
 	uiGeneralTab.tbFunctions1->setIcon( QIcon::fromTheme("preferences-desktop-font") );
 
 	uiGeneralTab.tbConstants2->setIcon( QIcon::fromTheme("labplot-format-text-symbol") );
 	uiGeneralTab.tbFunctions2->setIcon( QIcon::fromTheme("preferences-desktop-font") );
 
 	uiGeneralTab.cbType->addItem(i18n("Cartesian"));
 	uiGeneralTab.cbType->addItem(i18n("Polar"));
 	uiGeneralTab.cbType->addItem(i18n("Parametric"));
 // 	uiGeneralTab.cbType->addItem(i18n("Implicit"));
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	uiGeneralTab.teEquation2->setExpressionType(XYEquationCurve::Parametric);
 
 	uiGeneralTab.teEquation1->setMaximumHeight(uiGeneralTab.leName->sizeHint().height()*2);
 	uiGeneralTab.teEquation2->setMaximumHeight(uiGeneralTab.leName->sizeHint().height()*2);
 	uiGeneralTab.teMin->setMaximumHeight(uiGeneralTab.leName->sizeHint().height());
 	uiGeneralTab.teMax->setMaximumHeight(uiGeneralTab.leName->sizeHint().height());
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYEquationCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYEquationCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)) );
 	connect( uiGeneralTab.teEquation1, SIGNAL(expressionChanged()), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.teEquation2, SIGNAL(expressionChanged()), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.tbConstants1, SIGNAL(clicked()), this, SLOT(showConstants()) );
 	connect( uiGeneralTab.tbFunctions1, SIGNAL(clicked()), this, SLOT(showFunctions()) );
 	connect( uiGeneralTab.tbConstants2, SIGNAL(clicked()), this, SLOT(showConstants()) );
 	connect( uiGeneralTab.tbFunctions2, SIGNAL(clicked()), this, SLOT(showFunctions()) );
 	connect( uiGeneralTab.teMin, SIGNAL(expressionChanged()), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.teMax, SIGNAL(expressionChanged()), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.sbCount, SIGNAL(valueChanged(int)), this, SLOT(enableRecalculate()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYEquationCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_equationCurve = dynamic_cast<XYEquationCurve*>(m_curve);
 	Q_ASSERT(m_equationCurve);
 	m_aspectTreeModel =  new AspectTreeModel(m_curve->project());
 	XYCurveDock::setModel();
 	initGeneralTab();
 	initTabs();
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	m_initializing=false;
 }
 
 void XYEquationCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1){
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
-	const auto equationCurve = dynamic_cast<const XYEquationCurve*>(m_curve);
+	const auto* equationCurve = dynamic_cast<const XYEquationCurve*>(m_curve);
 	Q_ASSERT(equationCurve);
 	const XYEquationCurve::EquationData& data = equationCurve->equationData();
 	uiGeneralTab.cbType->setCurrentIndex(data.type);
 	this->typeChanged(data.type);
 	uiGeneralTab.teEquation1->setText(data.expression1);
 	uiGeneralTab.teEquation2->setText(data.expression2);
 	uiGeneralTab.teMin->setText(data.min);
 	uiGeneralTab.teMax->setText(data.max);
 	uiGeneralTab.sbCount->setValue(data.count);
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_equationCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),
 			this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_equationCurve, SIGNAL(equationDataChanged(XYEquationCurve::EquationData)),
 			this, SLOT(curveEquationDataChanged(XYEquationCurve::EquationData)));
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYEquationCurveDock *****
 //*************************************************************
 void XYEquationCurveDock::nameChanged(){
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYEquationCurveDock::commentChanged(){
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYEquationCurveDock::typeChanged(int index) {
 	const auto type = XYEquationCurve::EquationType(index);
 	if (type == XYEquationCurve::Cartesian) {
 		uiGeneralTab.lEquation1->setText("y=f(x)");
 		uiGeneralTab.lEquation2->hide();
 		uiGeneralTab.teEquation2->hide();
 		uiGeneralTab.tbFunctions2->hide();
 		uiGeneralTab.tbConstants2->hide();
 		uiGeneralTab.lMin->show();
 		uiGeneralTab.lMax->show();
 		uiGeneralTab.teMin->show();
 		uiGeneralTab.teMax->show();
 		uiGeneralTab.lMin->setText(i18n("x, min"));
 		uiGeneralTab.lMax->setText(i18n("x, max"));
 	} else if (type == XYEquationCurve::Polar) {
 		uiGeneralTab.lEquation1->setText(QString::fromUtf8("r(φ)"));
 		uiGeneralTab.lEquation2->hide();
 		uiGeneralTab.teEquation2->hide();
 		uiGeneralTab.tbFunctions2->hide();
 		uiGeneralTab.tbConstants2->hide();
 		uiGeneralTab.lMin->show();
 		uiGeneralTab.lMax->show();
 		uiGeneralTab.teMin->show();
 		uiGeneralTab.teMax->show();
 		uiGeneralTab.lMin->setText(i18n("φ, min"));
 		uiGeneralTab.lMax->setText(i18n("φ, max"));
 	} else if (type == XYEquationCurve::Parametric) {
 		uiGeneralTab.lEquation1->setText("x=f(t)");
 		uiGeneralTab.lEquation2->setText("y=f(t)");
 		uiGeneralTab.lEquation2->show();
 		uiGeneralTab.teEquation2->show();
 		uiGeneralTab.tbFunctions2->show();
 		uiGeneralTab.tbConstants2->show();
 		uiGeneralTab.lMin->show();
 		uiGeneralTab.lMax->show();
 		uiGeneralTab.teMin->show();
 		uiGeneralTab.teMax->show();
 		uiGeneralTab.lMin->setText(i18n("t, min"));
 		uiGeneralTab.lMax->setText(i18n("t, max"));
 	} else if (type == XYEquationCurve::Implicit) {
 		uiGeneralTab.lEquation1->setText("f(x,y)");
 		uiGeneralTab.lEquation2->hide();
 		uiGeneralTab.teEquation2->hide();
 		uiGeneralTab.tbFunctions2->hide();
 		uiGeneralTab.tbConstants2->hide();
 		uiGeneralTab.lMin->hide();
 		uiGeneralTab.lMax->hide();
 		uiGeneralTab.teMin->hide();
 		uiGeneralTab.teMax->hide();
 	}
 
 	uiGeneralTab.teEquation1->setExpressionType(type);
 	this->enableRecalculate();
 }
 
 void XYEquationCurveDock::recalculateClicked() {
 	XYEquationCurve::EquationData data;
 	data.type = (XYEquationCurve::EquationType)uiGeneralTab.cbType->currentIndex();
 	data.expression1 = uiGeneralTab.teEquation1->document()->toPlainText();
 	data.expression2 = uiGeneralTab.teEquation2->document()->toPlainText();
 	data.min = uiGeneralTab.teMin->document()->toPlainText();
 	data.max = uiGeneralTab.teMax->document()->toPlainText();
 	data.count = uiGeneralTab.sbCount->value();
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYEquationCurve*>(curve)->setEquationData(data);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 }
 
 void XYEquationCurveDock::showConstants() {
 	QMenu menu;
 	ConstantsWidget constants(&menu);
 
 	if (QObject::sender() == uiGeneralTab.tbConstants1)
 		connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant1(QString)));
 	else
 		connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant2(QString)));
 
 	connect(&constants, SIGNAL(constantSelected(QString)), &menu, SLOT(close()));
 	connect(&constants, SIGNAL(canceled()), &menu, SLOT(close()));
 
-	auto widgetAction = new QWidgetAction(this);
+	auto* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&constants);
 	menu.addAction(widgetAction);
 
 	if (QObject::sender() == uiGeneralTab.tbConstants1) {
 		QPoint pos(-menu.sizeHint().width()+uiGeneralTab.tbConstants1->width(),-menu.sizeHint().height());
 		menu.exec(uiGeneralTab.tbConstants1->mapToGlobal(pos));
 	} else {
 		QPoint pos(-menu.sizeHint().width()+uiGeneralTab.tbConstants2->width(),-menu.sizeHint().height());
 		menu.exec(uiGeneralTab.tbConstants2->mapToGlobal(pos));
 	}
 }
 
 void XYEquationCurveDock::showFunctions() {
 	QMenu menu;
 	FunctionsWidget functions(&menu);
 	if (QObject::sender() == uiGeneralTab.tbFunctions1)
 		connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction1(QString)));
 	else
 		connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction2(QString)));
 
 	connect(&functions, SIGNAL(functionSelected(QString)), &menu, SLOT(close()));
 	connect(&functions, SIGNAL(canceled()), &menu, SLOT(close()));
 
-	auto widgetAction = new QWidgetAction(this);
+	auto* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&functions);
 	menu.addAction(widgetAction);
 
 	if (QObject::sender() == uiGeneralTab.tbFunctions1) {
 		QPoint pos(-menu.sizeHint().width()+uiGeneralTab.tbFunctions1->width(),-menu.sizeHint().height());
 		menu.exec(uiGeneralTab.tbFunctions1->mapToGlobal(pos));
 	} else {
 		QPoint pos(-menu.sizeHint().width()+uiGeneralTab.tbFunctions2->width(),-menu.sizeHint().height());
 		menu.exec(uiGeneralTab.tbFunctions2->mapToGlobal(pos));
 	}
 }
 
 void XYEquationCurveDock::insertFunction1(const QString& str) {
 	//TODO: not all functions have only one argument
 	const auto type = XYEquationCurve::EquationType(uiGeneralTab.cbType->currentIndex());
 	if (type == XYEquationCurve::Cartesian)
 		uiGeneralTab.teEquation1->insertPlainText(str + "(x)");
 	else if (type == XYEquationCurve::Polar)
 		uiGeneralTab.teEquation1->insertPlainText(str + "(phi)");
 	else if (type == XYEquationCurve::Parametric)
 		uiGeneralTab.teEquation1->insertPlainText(str + "(t)");
 }
 
 void XYEquationCurveDock::insertConstant1(const QString& str) {
 	uiGeneralTab.teEquation1->insertPlainText(str);
 }
 
 void XYEquationCurveDock::insertFunction2(const QString& str) {
 	//TODO: not all functions have only one argument
 	uiGeneralTab.teEquation2->insertPlainText(str + "(t)");
 }
 
 void XYEquationCurveDock::insertConstant2(const QString& str) {
 	uiGeneralTab.teEquation2->insertPlainText(str);
 }
 
 void XYEquationCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//check whether the formular expressions are correct
 	bool valid = false;
 	const auto type = XYEquationCurve::EquationType(uiGeneralTab.cbType->currentIndex());
 	if (type != XYEquationCurve::Parametric)
 		valid = uiGeneralTab.teEquation1->isValid();
 	else
 		valid = (uiGeneralTab.teEquation1->isValid() && uiGeneralTab.teEquation2->isValid());
 
 	valid = (valid && uiGeneralTab.teMin->isValid() && uiGeneralTab.teMax->isValid());
 	uiGeneralTab.pbRecalculate->setEnabled(valid);
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYEquationCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text()) {
 		uiGeneralTab.leName->setText(aspect->name());
 	} else if (aspect->comment() != uiGeneralTab.leComment->text()) {
 		uiGeneralTab.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void XYEquationCurveDock::curveEquationDataChanged(const XYEquationCurve::EquationData& data) {
 	m_initializing = true;
 	uiGeneralTab.cbType->setCurrentIndex(data.type);
 	uiGeneralTab.teEquation1->setText(data.expression1);
 	uiGeneralTab.teEquation2->setText(data.expression2);
 	uiGeneralTab.teMin->setText(data.min);
 	uiGeneralTab.teMax->setText(data.max);
 	uiGeneralTab.sbCount->setValue(data.count);
 	m_initializing = false;
 }
diff --git a/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp b/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
index 242693480..1d789b371 100644
--- a/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYFitCurveDock.cpp
@@ -1,1349 +1,1349 @@
 /***************************************************************************
     File             : XYFitCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2014-2017 Alexander Semke (alexander.semke@web.de)
     Copyright        : (C) 2016-2018 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description      : widget for editing properties of fit curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYFitCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/lib/macros.h"
 #include "backend/gsl/ExpressionParser.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/widgets/ConstantsWidget.h"
 #include "kdefrontend/widgets/FunctionsWidget.h"
 #include "kdefrontend/widgets/FitOptionsWidget.h"
 #include "kdefrontend/widgets/FitParametersWidget.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 #include <QStandardPaths>
 #include <QClipboard>
 #include <QDir>
 
 extern "C" {
 #include "backend/nsl/nsl_sf_stats.h"
 }
 
 /*!
   \class XYFitCurveDock
   \brief  Provides a widget for editing the properties of the XYFitCurves
 		(2D-curves defined by a fit model) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYFitCurveDock::XYFitCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr), cbXDataColumn(nullptr), cbYDataColumn(nullptr), cbXErrorColumn(nullptr),
 	cbYErrorColumn(nullptr), m_fitCurve(nullptr), m_parametersValid(true) {
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	set up "General" tab
  */
 void XYFitCurveDock::setupGeneral() {
 	DEBUG("XYFitCurveDock::setupGeneral()");
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 	QGridLayout* gridLayout = qobject_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2, 2, 2, 2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 6, 4, 1, 4);
 
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 7, 4, 1, 4);
 
 	cbXErrorColumn = new TreeViewComboBox(generalTab);
 	cbXErrorColumn->setEnabled(false);
 	uiGeneralTab.hlXError->addWidget(cbXErrorColumn);
 
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 8, 4, 1, 4);
 
 	cbYErrorColumn = new TreeViewComboBox(generalTab);
 	cbYErrorColumn->setEnabled(false);
 	uiGeneralTab.hlYWeight->addWidget(cbYErrorColumn);
 
 	// X/Y-Weight
 	for(int i = 0; i < NSL_FIT_WEIGHT_TYPE_COUNT; i++) {
 		uiGeneralTab.cbXWeight->addItem(nsl_fit_weight_type_name[i]);
 		uiGeneralTab.cbYWeight->addItem(nsl_fit_weight_type_name[i]);
 	}
 	uiGeneralTab.cbXWeight->setCurrentIndex(nsl_fit_weight_no);
 	uiGeneralTab.cbYWeight->setCurrentIndex(nsl_fit_weight_no);
 
 	for(int i = 0; i < NSL_FIT_MODEL_CATEGORY_COUNT; i++)
 		uiGeneralTab.cbCategory->addItem(nsl_fit_model_category_name[i]);
 
 	uiGeneralTab.teEquation->setMaximumHeight(uiGeneralTab.leName->sizeHint().height() * 2);
 
 	fitParametersWidget = new FitParametersWidget(generalTab);
 	gridLayout->addWidget(fitParametersWidget, 21, 4, 1, 4);
 
 	//use white background in the preview label
 	QPalette p;
 	p.setColor(QPalette::Window, Qt::white);
 	uiGeneralTab.lFuncPic->setAutoFillBackground(true);
 	uiGeneralTab.lFuncPic->setPalette(p);
 
 	uiGeneralTab.tbConstants->setIcon(QIcon::fromTheme("labplot-format-text-symbol"));
 	uiGeneralTab.tbFunctions->setIcon(QIcon::fromTheme("preferences-desktop-font"));
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	// TODO: setting checked background color to unchecked color
 //	p = uiGeneralTab.lData->palette();
 	// QWidget::palette().color(QWidget::backgroundRole())
 	// not working with 'transparent'
 //	p.setColor(QPalette::Base, Qt::transparent);
 //	uiGeneralTab.lData->setPalette(p);
 	// see https://forum.qt.io/topic/41325/solved-background-of-checked-qpushbutton-with-stylesheet/2
 	// Styles not usable (here: text color not theme dependent). see https://forum.qt.io/topic/60546/qpushbutton-default-windows-style-sheet/9
 //	uiGeneralTab.lData->setStyleSheet("QToolButton:checked{background-color: transparent;border: 3px transparent;padding: 3px;}");
 
 //	uiGeneralTab.lData->setAutoFillBackground(true);
 
 	uiGeneralTab.twLog->setEditTriggers(QAbstractItemView::NoEditTriggers);
 	uiGeneralTab.twParameters->setEditTriggers(QAbstractItemView::NoEditTriggers);
 	uiGeneralTab.twGoodness->setEditTriggers(QAbstractItemView::NoEditTriggers);
 
 	//don't allow word wrapping in the log-table for the multi-line iterations string
 	uiGeneralTab.twLog->setWordWrap(false);
 
 	// show these options per default
 	showDataOptions(true);
 	showFitOptions(true);
 	showParameters(true);
 	showResults(true);
 	// hide these options per default
 	showWeightsOptions(false);
 
 	// context menus
 	uiGeneralTab.twParameters->setContextMenuPolicy(Qt::CustomContextMenu);
 	uiGeneralTab.twGoodness->setContextMenuPolicy(Qt::CustomContextMenu);
 	uiGeneralTab.twLog->setContextMenuPolicy(Qt::CustomContextMenu);
 	connect(uiGeneralTab.twParameters, SIGNAL(customContextMenuRequested(QPoint)), this,
 			SLOT(resultParametersContextMenuRequest(QPoint)) );
 	connect(uiGeneralTab.twGoodness, SIGNAL(customContextMenuRequested(QPoint)), this,
 			SLOT(resultGoodnessContextMenuRequest(QPoint)) );
 	connect(uiGeneralTab.twLog, SIGNAL(customContextMenuRequested(QPoint)), this,
 			SLOT(resultLogContextMenuRequest(QPoint)) );
 
 	uiGeneralTab.twLog->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 	uiGeneralTab.twGoodness->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
 	uiGeneralTab.twGoodness->item(0, 1)->setText(UTF8_QSTRING("χ²"));
 	uiGeneralTab.twGoodness->item(1, 1)->setText(i18n("reduced") + ' ' + UTF8_QSTRING("χ²")
 		+ " (" + UTF8_QSTRING("χ²") + "/dof)");
 	uiGeneralTab.twGoodness->item(3, 1)->setText(UTF8_QSTRING("R²"));
 	uiGeneralTab.twGoodness->item(4, 1)->setText(UTF8_QSTRING("R̄²"));
 	uiGeneralTab.twGoodness->item(5, 0)->setText(UTF8_QSTRING("χ²") + ' ' + i18n("test"));
 	uiGeneralTab.twGoodness->item(5, 1)->setText("P > " + UTF8_QSTRING("χ²"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect(uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYFitCurveDock::nameChanged);
 	connect(uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYFitCurveDock::commentChanged);
 	connect(uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)));
 	connect(uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)));
 
 	connect(uiGeneralTab.lWeights, &QPushButton::clicked, this, &XYFitCurveDock::showWeightsOptions);
 	connect(uiGeneralTab.cbXWeight, SIGNAL(currentIndexChanged(int)), this, SLOT(xWeightChanged(int)));
 	connect(uiGeneralTab.cbYWeight, SIGNAL(currentIndexChanged(int)), this, SLOT(yWeightChanged(int)));
 	connect(uiGeneralTab.cbCategory, SIGNAL(currentIndexChanged(int)), this, SLOT(categoryChanged(int)));
 	connect(uiGeneralTab.cbModel, SIGNAL(currentIndexChanged(int)), this, SLOT(modelTypeChanged(int)));
 	connect(uiGeneralTab.sbDegree, SIGNAL(valueChanged(int)), this, SLOT(updateModelEquation()));
 	connect(uiGeneralTab.teEquation, SIGNAL(expressionChanged()), this, SLOT(expressionChanged()));
 	connect(uiGeneralTab.tbConstants, SIGNAL(clicked()), this, SLOT(showConstants()));
 	connect(uiGeneralTab.tbFunctions, SIGNAL(clicked()), this, SLOT(showFunctions()));
 	connect(uiGeneralTab.pbOptions, SIGNAL(clicked()), this, SLOT(showOptions()));
 	connect(uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()));
 	connect(uiGeneralTab.lData, &QPushButton::clicked, this, &XYFitCurveDock::showDataOptions);
 	connect(uiGeneralTab.lFit, &QPushButton::clicked, this, &XYFitCurveDock::showFitOptions);
 	connect(uiGeneralTab.lParameters, &QPushButton::clicked, this, &XYFitCurveDock::showParameters);
 	connect(uiGeneralTab.lResults, &QPushButton::clicked, this, &XYFitCurveDock::showResults);
 
 	connect(cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)));
 	connect(cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)));
 	connect(cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)));
 	connect(cbXErrorColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xErrorColumnChanged(QModelIndex)));
 	connect(cbYErrorColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yErrorColumnChanged(QModelIndex)));
 
 }
 
 /*
  * load curve settings
  */
 void XYFitCurveDock::initGeneralTab() {
 	DEBUG("XYFitCurveDock::initGeneralTab()");
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size() == 1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	} else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_fitCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_fitCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_fitCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_fitCurve->yDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbXErrorColumn, m_fitCurve->xErrorColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYErrorColumn, m_fitCurve->yErrorColumn());
 
 	int tmpModelType = m_fitData.modelType;	// save type because it's reset when category changes
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		uiGeneralTab.cbCategory->setCurrentIndex(uiGeneralTab.cbCategory->count() - 1);
 	else
 		uiGeneralTab.cbCategory->setCurrentIndex(m_fitData.modelCategory);
 	if (m_fitData.modelCategory != nsl_fit_model_custom)
 		uiGeneralTab.cbModel->setCurrentIndex(tmpModelType);
 	m_fitData.modelType = tmpModelType;
 	categoryChanged(m_fitData.modelCategory);	// fill model types
 
 	uiGeneralTab.cbXWeight->setCurrentIndex(m_fitData.xWeightsType);
 	uiGeneralTab.cbYWeight->setCurrentIndex(m_fitData.yWeightsType);
 	uiGeneralTab.sbDegree->setValue(m_fitData.degree);
 
 	if (m_fitData.paramStartValues.size() > 0) {
 		DEBUG("	B start value 0 = " << m_fitData.paramStartValues.at(0));
 	}
 	DEBUG("	B model degree = " << m_fitData.degree);
 
 	this->showFitResult();
 
 	uiGeneralTab.chkVisible->setChecked(m_curve->isVisible());
 
 	//Slots
 	connect(m_fitCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_fitCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_fitCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_fitCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(xErrorColumnChanged(const AbstractColumn*)), this, SLOT(curveXErrorColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(yErrorColumnChanged(const AbstractColumn*)), this, SLOT(curveYErrorColumnChanged(const AbstractColumn*)));
 	connect(m_fitCurve, SIGNAL(fitDataChanged(XYFitCurve::FitData)), this, SLOT(curveFitDataChanged(XYFitCurve::FitData)));
 	connect(m_fitCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 
 	connect(fitParametersWidget, &FitParametersWidget::parametersChanged, this, &XYFitCurveDock::parametersChanged);
 	connect(fitParametersWidget, &FitParametersWidget::parametersValid, this, &XYFitCurveDock::parametersValid);
 }
 
 void XYFitCurveDock::setModel() {
 	DEBUG("XYFitCurveDock::setModel()");
 	QList<const char*> list;
 	list << "Folder" << "Datapicker" << "Worksheet" << "CartesianPlot" << "XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve : m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list << "Folder" << "Workbook" << "Spreadsheet" << "FileDataSource" << "Column" << "CantorWorksheet" << "Datapicker";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 	cbXErrorColumn->setTopLevelClasses(list);
 	cbYErrorColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 	cbXErrorColumn->setModel(m_aspectTreeModel);
 	cbYErrorColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYFitCurveDock::setCurves(QList<XYCurve*> list) {
 	DEBUG("XYFitCurveDock::setCurves()");
 	m_initializing = true;
 	m_curvesList = list;
 	m_curve = list.first();
 
 	m_fitCurve = dynamic_cast<XYFitCurve*>(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_fitData = m_fitCurve->fitData();
 	if(m_fitData.paramStartValues.size() > 0) {
 		DEBUG("	A start value 0 = " << m_fitData.paramStartValues.at(0));
 	}
 	DEBUG("	A model degree = " << m_fitData.degree);
 	fitParametersWidget->setFitData(&m_fitData);
 
 	initGeneralTab();
 	initTabs();
 
 	m_initializing = false;
 
 	//init parameter list when not available
 	if (m_fitData.paramStartValues.size() == 0)
 		updateModelEquation();
 
 	enableRecalculate();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYFitCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYFitCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYFitCurveDock::dataSourceTypeChanged(int index) {
 	const XYAnalysisCurve::DataSourceType type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYFitCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYFitCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	DEBUG("XYFitCurveDock::xDataColumnChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setXDataColumn(column);
 
 	// set model dependent start values from new data
 	XYFitCurve::initStartValues(m_fitData, m_curve);
 }
 
 void XYFitCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	DEBUG("XYFitCurveDock::yDataColumnChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setYDataColumn(column);
 
 	// set model dependent start values from new data
 	XYFitCurve::initStartValues(m_fitData, m_curve);
 }
 
 void XYFitCurveDock::xErrorColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setXErrorColumn(column);
 }
 
 void XYFitCurveDock::yErrorColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setYErrorColumn(column);
 }
 
 ///////////////////////// fold/unfold options //////////////////////////////////////////////////
 
 void XYFitCurveDock::showDataOptions(bool checked) {
 	if (checked) {
 		uiGeneralTab.lData->setIcon(QIcon::fromTheme("arrow-down"));
 		uiGeneralTab.lDataSourceType->show();
 		uiGeneralTab.cbDataSourceType->show();
 		// select options for current source type
 		dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	} else {
 		uiGeneralTab.lData->setIcon(QIcon::fromTheme("arrow-right"));
 		uiGeneralTab.lDataSourceType->hide();
 		uiGeneralTab.cbDataSourceType->hide();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 	}
 }
 
 void XYFitCurveDock::showWeightsOptions(bool checked) {
 	if (checked) {
 		uiGeneralTab.lWeights->setIcon(QIcon::fromTheme("arrow-down"));
 		uiGeneralTab.lXWeight->show();
 		uiGeneralTab.cbXWeight->show();
 		uiGeneralTab.lXErrorCol->show();
 		cbXErrorColumn->show();
 		uiGeneralTab.lYWeight->show();
 		uiGeneralTab.cbYWeight->show();
 		uiGeneralTab.lYErrorCol->show();
 		cbYErrorColumn->show();
 	} else {
 		uiGeneralTab.lWeights->setIcon(QIcon::fromTheme("arrow-right"));
 		uiGeneralTab.lXWeight->hide();
 		uiGeneralTab.cbXWeight->hide();
 		uiGeneralTab.lXErrorCol->hide();
 		cbXErrorColumn->hide();
 		uiGeneralTab.lYWeight->hide();
 		uiGeneralTab.cbYWeight->hide();
 		uiGeneralTab.lYErrorCol->hide();
 		cbYErrorColumn->hide();
 	}
 }
 
 void XYFitCurveDock::showFitOptions(bool checked) {
 	if (checked) {
 		uiGeneralTab.lFit->setIcon(QIcon::fromTheme("arrow-down"));
 		uiGeneralTab.lCategory->show();
 		uiGeneralTab.cbCategory->show();
 		uiGeneralTab.lModel->show();
 		uiGeneralTab.cbModel->show();
 		uiGeneralTab.lEquation->show();
 
 		m_initializing = true;	// do not change start parameter
 		modelTypeChanged(uiGeneralTab.cbModel->currentIndex());
 		m_initializing = false;
 	} else {
 		uiGeneralTab.lFit->setIcon(QIcon::fromTheme("arrow-right"));
 		uiGeneralTab.lCategory->hide();
 		uiGeneralTab.cbCategory->hide();
 		uiGeneralTab.lModel->hide();
 		uiGeneralTab.cbModel->hide();
 		uiGeneralTab.lDegree->hide();
 		uiGeneralTab.sbDegree->hide();
 		uiGeneralTab.lEquation->hide();
 		uiGeneralTab.lFuncPic->hide();
 		uiGeneralTab.teEquation->hide();
 		uiGeneralTab.tbFunctions->hide();
 		uiGeneralTab.tbConstants->hide();
 	}
 }
 
 void XYFitCurveDock::showParameters(bool checked) {
 	if (checked) {
 		uiGeneralTab.lParameters->setIcon(QIcon::fromTheme("arrow-down"));
 		fitParametersWidget->show();
 	} else {
 		uiGeneralTab.lParameters->setIcon(QIcon::fromTheme("arrow-right"));
 		fitParametersWidget->hide();
 	}
 }
 
 void XYFitCurveDock::showResults(bool checked) {
 	if (checked) {
 		uiGeneralTab.lResults->setIcon(QIcon::fromTheme("arrow-down"));
 		uiGeneralTab.twResults->show();
 	} else {
 		uiGeneralTab.lResults->setIcon(QIcon::fromTheme("arrow-right"));
 		uiGeneralTab.twResults->hide();
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
 void XYFitCurveDock::xWeightChanged(int index) {
 	DEBUG("xWeightChanged() weight = " << nsl_fit_weight_type_name[index]);
 
 	m_fitData.xWeightsType = (nsl_fit_weight_type)index;
 
 	// enable/disable weight column
 	switch ((nsl_fit_weight_type)index) {
 	case nsl_fit_weight_no:
 	case nsl_fit_weight_statistical:
 	case nsl_fit_weight_statistical_fit:
 	case nsl_fit_weight_relative:
 	case nsl_fit_weight_relative_fit:
 		cbXErrorColumn->setEnabled(false);
 		uiGeneralTab.lXErrorCol->setEnabled(false);
 		break;
 	case nsl_fit_weight_instrumental:
 	case nsl_fit_weight_direct:
 	case nsl_fit_weight_inverse:
 		cbXErrorColumn->setEnabled(true);
 		uiGeneralTab.lXErrorCol->setEnabled(true);
 		break;
 	}
 	enableRecalculate();
 }
 
 void XYFitCurveDock::yWeightChanged(int index) {
 	DEBUG("yWeightChanged() weight = " << nsl_fit_weight_type_name[index]);
 
 	m_fitData.yWeightsType = (nsl_fit_weight_type)index;
 
 	// enable/disable weight column
 	switch ((nsl_fit_weight_type)index) {
 	case nsl_fit_weight_no:
 	case nsl_fit_weight_statistical:
 	case nsl_fit_weight_statistical_fit:
 	case nsl_fit_weight_relative:
 	case nsl_fit_weight_relative_fit:
 		cbYErrorColumn->setEnabled(false);
 		uiGeneralTab.lYErrorCol->setEnabled(false);
 		break;
 	case nsl_fit_weight_instrumental:
 	case nsl_fit_weight_direct:
 	case nsl_fit_weight_inverse:
 		cbYErrorColumn->setEnabled(true);
 		uiGeneralTab.lYErrorCol->setEnabled(true);
 		break;
 	}
 	enableRecalculate();
 }
 
 /*!
  * called when the fit model category (basic functions, peak functions etc.) was changed.
  * In the combobox for the model type shows the model types for the current category \index and calls \c modelTypeChanged()
  * to update the model type dependent widgets in the general-tab.
  */
 void XYFitCurveDock::categoryChanged(int index) {
 	if (index == nsl_fit_model_custom) {
 		DEBUG("categoryChanged() category = \"nsl_fit_model_custom\"");
 	} else {
 		DEBUG("categoryChanged() category = \"" << nsl_fit_model_category_name[index] << "\"");
 	}
 
 	bool hasChanged = true;
 	// nothing has changed when ...
 	if (m_fitData.modelCategory == (nsl_fit_model_category)index || (m_fitData.modelCategory == nsl_fit_model_custom && index == uiGeneralTab.cbCategory->count() - 1) )
 		hasChanged = false;
 
 	if (uiGeneralTab.cbCategory->currentIndex() == uiGeneralTab.cbCategory->count() - 1)
 		m_fitData.modelCategory = nsl_fit_model_custom;
 	else
 		m_fitData.modelCategory = (nsl_fit_model_category)index;
 
 	uiGeneralTab.cbModel->clear();
 	uiGeneralTab.cbModel->show();
 	uiGeneralTab.lModel->show();
 
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic:
 		for(int i = 0; i < NSL_FIT_MODEL_BASIC_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_basic_name[i]);
 		break;
 	case nsl_fit_model_peak: {
 		for(int i = 0; i < NSL_FIT_MODEL_PEAK_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_peak_name[i]);
 #if defined(_MSC_VER)
 		// disable voigt model
 		const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbModel->model());
 		QStandardItem* item = model->item(nsl_fit_model_voigt);
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 #endif
 		break;
 	}
 	case nsl_fit_model_growth:
 		for(int i = 0; i < NSL_FIT_MODEL_GROWTH_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_fit_model_growth_name[i]);
 		break;
 	case nsl_fit_model_distribution: {
 		for(int i = 0; i < NSL_SF_STATS_DISTRIBUTION_COUNT; i++)
 			uiGeneralTab.cbModel->addItem(nsl_sf_stats_distribution_name[i]);
 
 		// not-used items are disabled here
 		const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbModel->model());
 
 		for(int i = 1; i < NSL_SF_STATS_DISTRIBUTION_COUNT; i++) {
 			// unused distributions
 			if (i == nsl_sf_stats_levy_alpha_stable || i == nsl_sf_stats_levy_skew_alpha_stable || i == nsl_sf_stats_bernoulli) {
 					QStandardItem* item = model->item(i);
 					item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 			}
 		}
 		break;
 	}
 	case nsl_fit_model_custom:
 		uiGeneralTab.cbModel->addItem(i18n("Custom"));
 		uiGeneralTab.cbModel->hide();
 		uiGeneralTab.lModel->hide();
 	}
 
 	if (hasChanged) {
 		//show the fit-model for the currently selected default (first) fit-model
 		uiGeneralTab.cbModel->setCurrentIndex(0);
 		uiGeneralTab.sbDegree->setValue(1);
 		// when model type does not change, call it here
 		updateModelEquation();
 	}
 
 	enableRecalculate();
 }
 
 /*!
  * called when the fit model type (depends on category) was changed.
  * Updates the model type dependent widgets in the general-tab and calls \c updateModelEquation() to update the preview pixmap.
  */
 void XYFitCurveDock::modelTypeChanged(int index) {
 	DEBUG("modelTypeChanged() type = " << index << ", initializing = " << m_initializing << ", current type = " << m_fitData.modelType);
 	// leave if there is no selection
 	if(index == -1)
 		return;
 
 	bool custom = false;
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		custom = true;
 	uiGeneralTab.teEquation->setReadOnly(!custom);
 	uiGeneralTab.lModel->setVisible(!custom);
 	uiGeneralTab.cbModel->setVisible(!custom);
 	uiGeneralTab.tbFunctions->setVisible(custom);
 	uiGeneralTab.tbConstants->setVisible(custom);
 
 	// default settings
 	uiGeneralTab.lDegree->setText(i18n("Degree:"));
 	if (m_fitData.modelType != index)
 		uiGeneralTab.sbDegree->setValue(1);
 
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic:
 		switch (index) {
 		case nsl_fit_model_polynomial:
 		case nsl_fit_model_fourier:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(10);
 			break;
 		case nsl_fit_model_power:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(2);
 			break;
 		case nsl_fit_model_exponential:
 			uiGeneralTab.lDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setVisible(true);
 			uiGeneralTab.sbDegree->setMaximum(10);
 			break;
 		default:
 			uiGeneralTab.lDegree->setVisible(false);
 			uiGeneralTab.sbDegree->setVisible(false);
 		}
 		break;
 	case nsl_fit_model_peak:	// all models support multiple peaks
 		uiGeneralTab.lDegree->setText(i18n("Number of peaks:"));
 		uiGeneralTab.lDegree->setVisible(true);
 		uiGeneralTab.sbDegree->setVisible(true);
 		uiGeneralTab.sbDegree->setMaximum(9);
 		break;
 	case nsl_fit_model_growth:
 	case nsl_fit_model_distribution:
 	case nsl_fit_model_custom:
 		uiGeneralTab.lDegree->setVisible(false);
 		uiGeneralTab.sbDegree->setVisible(false);
 	}
 
 	m_fitData.modelType = index;
 
 	updateModelEquation();
 }
 
 /*!
  * Show the preview pixmap of the fit model expression for the current model category and type.
  * Called when the model type or the degree of the model were changed.
  */
 void XYFitCurveDock::updateModelEquation() {
 
 	if (m_fitData.modelCategory == nsl_fit_model_custom) {
 		DEBUG("XYFitCurveDock::updateModelEquation() category = nsl_fit_model_custom, type = " << m_fitData.modelType);
 	} else {
 		DEBUG("XYFitCurveDock::updateModelEquation() category = " << nsl_fit_model_category_name[m_fitData.modelCategory] << ", type = " << m_fitData.modelType);
 	}
 
 	//this function can also be called when the value for the degree was changed -> update the fit data structure
 	int degree = uiGeneralTab.sbDegree->value();
 	if (!m_initializing) {
 		m_fitData.degree = degree;
 		XYFitCurve::initFitData(m_fitData);
 		// set model dependent start values from curve data
 		XYFitCurve::initStartValues(m_fitData, m_curve);
 		// udpate parameter widget
 		fitParametersWidget->setFitData(&m_fitData);
 	}
 
 	// variables/parameter that are known
 	QStringList vars = {"x"};
 	vars << m_fitData.paramNames;
 	uiGeneralTab.teEquation->setVariables(vars);
 
 	// set formula picture
 	uiGeneralTab.lEquation->setText(QLatin1String("f(x) ="));
 	QString file;
 	switch (m_fitData.modelCategory) {
 	case nsl_fit_model_basic: {
 		// formula pic depends on degree
 		QString numSuffix = QString::number(degree);
 		if (degree > 4)
 			numSuffix = '4';
 		if ((nsl_fit_model_type_basic)m_fitData.modelType == nsl_fit_model_power && degree > 2)
 			numSuffix = '2';
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_basic_pic_name[m_fitData.modelType]) + numSuffix + ".png");
 		break;
 	}
 	case nsl_fit_model_peak: {
 		// formula pic depends on number of peaks
 		QString numSuffix = QString::number(degree);
 		if (degree > 4)
 			numSuffix = '4';
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_peak_pic_name[m_fitData.modelType]) + numSuffix + ".png");
 		break;
 	}
 	case nsl_fit_model_growth:
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/fit_models/"
 			+ QString(nsl_fit_model_growth_pic_name[m_fitData.modelType]) + ".png");
 		break;
 	case nsl_fit_model_distribution:
 		file = QStandardPaths::locate(QStandardPaths::AppDataLocation, "pics/gsl_distributions/"
 			+ QString(nsl_sf_stats_distribution_pic_name[m_fitData.modelType]) + ".png");
 		// change label
 		if (m_fitData.modelType == nsl_sf_stats_poisson)
 			uiGeneralTab.lEquation->setText(QLatin1String("f(k)/A ="));
 		else
 			uiGeneralTab.lEquation->setText(QLatin1String("f(x)/A ="));
 		break;
 	case nsl_fit_model_custom:
 		uiGeneralTab.lFuncPic->hide();
 		uiGeneralTab.teEquation->show();
 		uiGeneralTab.teEquation->setPlainText(m_fitData.model);
 	}
 
 	if (m_fitData.modelCategory != nsl_fit_model_custom) {
 		DEBUG("Model pixmap path = " << file.toStdString());
 		uiGeneralTab.lFuncPic->setPixmap(file);
 		uiGeneralTab.lFuncPic->show();
 		uiGeneralTab.teEquation->hide();
 	}
 
 	enableRecalculate();
 }
 
 void XYFitCurveDock::showConstants() {
 	QMenu menu;
 	ConstantsWidget constants(&menu);
 
 	connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant(QString)));
 	connect(&constants, SIGNAL(constantSelected(QString)), &menu, SLOT(close()));
 	connect(&constants, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&constants);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.tbConstants->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.tbConstants->mapToGlobal(pos));
 }
 
 void XYFitCurveDock::showFunctions() {
 	QMenu menu;
 	FunctionsWidget functions(&menu);
 	connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction(QString)));
 	connect(&functions, SIGNAL(functionSelected(QString)), &menu, SLOT(close()));
 	connect(&functions, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&functions);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.tbFunctions->width(), -menu.sizeHint().height());
 	menu.exec(uiGeneralTab.tbFunctions->mapToGlobal(pos));
 }
 
 /*!
  * Update parameter by parsing expression
  * Only called for custom fit model
  */
 void XYFitCurveDock::updateParameterList() {
 	DEBUG("XYFitCurveDock::updateParameterList()");
 	// use current model function
 	m_fitData.model = uiGeneralTab.teEquation->toPlainText();
 
 	ExpressionParser* parser = ExpressionParser::getInstance();
 	QStringList vars; // variables that are known
 	vars << "x";	//TODO: others?
 	m_fitData.paramNames = m_fitData.paramNamesUtf8 = parser->getParameter(m_fitData.model, vars);
 
 	// if number of parameter changed
 	int oldNumberOfParameter = m_fitData.paramStartValues.size();
 	int numberOfParameter = m_fitData.paramNames.size();
 	DEBUG(" old number of parameter: " << oldNumberOfParameter << " new number of parameter: " << numberOfParameter);
 	if (numberOfParameter != oldNumberOfParameter) {
 		m_fitData.paramStartValues.resize(numberOfParameter);
 		m_fitData.paramFixed.resize(numberOfParameter);
 		m_fitData.paramLowerLimits.resize(numberOfParameter);
 		m_fitData.paramUpperLimits.resize(numberOfParameter);
 	}
 	if (numberOfParameter > oldNumberOfParameter) {
 		for (int i = oldNumberOfParameter; i < numberOfParameter; ++i) {
 			m_fitData.paramStartValues[i] = 1.0;
 			m_fitData.paramFixed[i] = false;
 			m_fitData.paramLowerLimits[i] = -std::numeric_limits<double>::max();
 			m_fitData.paramUpperLimits[i] = std::numeric_limits<double>::max();
 		}
 	}
 
 	parametersChanged();
 }
 
 /*!
  * called when parameter names and/or start values for the model were changed
  * also called from parameter widget
  */
 void XYFitCurveDock::parametersChanged() {
 	DEBUG("XYFitCurveDock::parametersChanged() m_initializing = " << m_initializing);
 
 	//parameter names were (probably) changed -> set the new names in EquationTextEdit
 	uiGeneralTab.teEquation->setVariables(m_fitData.paramNames);
 
 	if (m_initializing)
 		return;
 
 	enableRecalculate();
 }
 void XYFitCurveDock::parametersValid(bool valid) {
 	DEBUG("XYFitCurveDock::parametersValid() valid = " << valid);
 	m_parametersValid = valid;
 }
 
 void XYFitCurveDock::showOptions() {
 	QMenu menu;
 	FitOptionsWidget w(&menu, &m_fitData, m_fitCurve);
 	connect(&w, SIGNAL(finished()), &menu, SLOT(close()));
 	connect(&w, SIGNAL(optionsChanged()), this, SLOT(enableRecalculate()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&w);
 	menu.addAction(widgetAction);
 	menu.setTearOffEnabled(true);
 
 	//menu.setWindowFlags(menu.windowFlags() & Qt::MSWindowsFixedSizeDialogHint);
 
 	QPoint pos(-menu.sizeHint().width() + uiGeneralTab.pbOptions->width(), 0);
 	menu.exec(uiGeneralTab.pbOptions->mapToGlobal(pos));
 }
 
 void XYFitCurveDock::insertFunction(const QString& str) const {
 	//TODO: not all function have only one argument!
 	uiGeneralTab.teEquation->insertPlainText(str + "(x)");
 }
 
 void XYFitCurveDock::insertConstant(const QString& str) const {
 	uiGeneralTab.teEquation->insertPlainText(str);
 }
 
 void XYFitCurveDock::recalculateClicked() {
 	DEBUG("XYFitCurveDock::recalculateClicked()");
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 	m_fitData.degree = uiGeneralTab.sbDegree->value();
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		updateParameterList();
 
 	for (XYCurve* curve: m_curvesList)
 		dynamic_cast<XYFitCurve*>(curve)->setFitData(m_fitData);
 
 	m_fitCurve->recalculate();
 
 	//update fitParametersWidget
 	if (m_fitData.useResults) {
 		for (int i = 0; i < m_fitData.paramNames.size(); i++)
 			m_fitData.paramStartValues[i] = m_fitCurve->fitResult().paramValues[i];
 		fitParametersWidget->setFitData(&m_fitData);
 	}
 
 	this->showFitResult();
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Fit status: %1", m_fitCurve->fitResult().status));
 	QApplication::restoreOverrideCursor();
 	DEBUG("XYFitCurveDock::recalculateClicked() DONE");
 }
 
 void XYFitCurveDock::expressionChanged() {
 	DEBUG("XYFitCurveDock::expressionChanged()");
 	if (m_initializing)
 		return;
 
 	// update parameter list for custom model
 	if (m_fitData.modelCategory == nsl_fit_model_custom)
 		updateParameterList();
 
 	enableRecalculate();
 }
 
 void XYFitCurveDock::enableRecalculate() const {
 	DEBUG("XYFitCurveDock::enableRecalculate()");
 	if (m_initializing || m_fitCurve == nullptr)
 		return;
 
 	//no fitting possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_fitCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX != nullptr && aspectY != nullptr);
 	} else {
 		hasSourceData = (m_fitCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData && m_parametersValid);
 
 	// PREVIEW as soon as recalculate is enabled (does not need source data)
 	if (m_parametersValid && m_fitData.previewEnabled) {
 		DEBUG("	ENABLE EVALUATE AND PREVIEW");
 		// use recent fit data
 		m_fitCurve->setFitData(m_fitData);
 		// calculate fit function
 		m_fitCurve->evaluate(true);
 	}
 	else {
 		DEBUG("	EVALUATE PREVIEW DISABLED");
 	}
 }
 
 void XYFitCurveDock::resultCopySelection() {
 	QTableWidget* tw{nullptr};
 	int currentTab = uiGeneralTab.twResults->currentIndex();
 	DEBUG("current tab = " << currentTab);
 	if (currentTab == 0)
 		tw = uiGeneralTab.twParameters;
 	else if (currentTab == 1)
 		tw = uiGeneralTab.twGoodness;
 	else if (currentTab == 2)
 		tw = uiGeneralTab.twLog;
 	else
 		return;
 
 	const QTableWidgetSelectionRange& range = tw->selectedRanges().constFirst();
 	QString str;
 	for (int i = 0; i < range.rowCount(); ++i) {
 		if (i > 0)
 			str += '\n';
 		for (int j = 0; j < range.columnCount(); ++j) {
 			if (j > 0)
 				str += '\t';
 			str += tw->item(range.topRow() + i, range.leftColumn() + j)->text();
 		}
 	}
 	str += '\n';
 	QApplication::clipboard()->setText(str);
 	DEBUG(QApplication::clipboard()->text().toStdString());
 }
 
 void XYFitCurveDock::resultCopyAll() {
 	const XYFitCurve::FitResult& fitResult = m_fitCurve->fitResult();
 	int currentTab = uiGeneralTab.twResults->currentIndex();
 	QString str;
 	if (currentTab == 0) {
 		str = i18n("Parameters:") + '\n';
 
 		const int np = fitResult.paramValues.size();
 		for (int i = 0; i < np; i++) {
 			if (m_fitData.paramFixed.at(i))
 				str += m_fitData.paramNamesUtf8.at(i) + QString(" = ") + QString::number(fitResult.paramValues.at(i)) + '\n';
 			else {
 				str += m_fitData.paramNamesUtf8.at(i) + QString(" = ") + QString::number(fitResult.paramValues.at(i))
 					+ UTF8_QSTRING("±") + QString::number(fitResult.errorValues.at(i))
 					+ " (" + QString::number(100.*fitResult.errorValues.at(i)/std::abs(fitResult.paramValues.at(i)), 'g', 3) + " %)\n";
 
 				const double margin = fitResult.tdist_marginValues.at(i);
 				QString tdistValueString;
 				if (fitResult.tdist_tValues.at(i) < std::numeric_limits<double>::max())
 					tdistValueString = QString::number(fitResult.tdist_tValues.at(i), 'g', 3);
 				else
 					tdistValueString = UTF8_QSTRING("∞");
 				str += " (" + i18n("t statistic:") + ' ' + tdistValueString + ", "
 					+ i18n("p value:") + ' ' + QString::number(fitResult.tdist_pValues.at(i), 'g', 3) + ", "
 					+ i18n("conf. interval:") + ' ';
 				if (std::abs(fitResult.tdist_tValues.at(i)) < 1.e6) {
 					str += QString::number(fitResult.paramValues.at(i) - margin) + " .. "
 						+ QString::number(fitResult.paramValues.at(i) + margin) + ")\n";
 				} else {
 					str += i18n("too small");
 				}
 			}
 		}
 	} else if (currentTab == 1) {
 		str = i18n("Goodness of fit:") + '\n';
 		str += i18n("sum of squared residuals") + " (" + UTF8_QSTRING("χ²") + "): " + QString::number(fitResult.sse) + '\n';
 		if (fitResult.dof != 0) {
 			str += i18n("reduced") + ' ' + UTF8_QSTRING("χ²") + ": " + QString::number(fitResult.rms) + '\n';
 			str += i18n("root mean square error") + " (RMSE): " + QString::number(fitResult.rsd) + '\n';
 			str += i18n("coefficient of determination") + " (" + UTF8_QSTRING("R²") + "): " + QString::number(fitResult.rsquare, 'g', 15) + '\n';
 			str += i18n("adj. coefficient of determination")+ " (" + UTF8_QSTRING("R̄²")
 				+ "): " + QString::number(fitResult.rsquareAdj, 'g', 15) + "\n\n";
 
 			str += i18n("P > ") + UTF8_QSTRING("χ²") + ": " + QString::number(fitResult.chisq_p, 'g', 3) + '\n';
 			str += i18n("F statistic") + ": " + QString::number(fitResult.fdist_F, 'g', 3) + '\n';
 			str += i18n("P > F") + ": " + QString::number(fitResult.fdist_p, 'g', 3) + '\n';
 		}
 		str += i18n("mean absolute error:") + ' ' + QString::number(fitResult.mae) + '\n';
 		str += i18n("Akaike information criterion:") + ' ' + QString::number(fitResult.aic) + '\n';
 		str += i18n("Bayesian information criterion:") + ' ' + QString::number(fitResult.bic) + '\n';
 	} else if (currentTab == 2) {
 		str = i18n("status:") + ' ' + fitResult.status + '\n';
 		str += i18n("iterations:") + ' ' + QString::number(fitResult.iterations) + '\n';
 		str += i18n("tolerance:") + ' ' + QString::number(m_fitData.eps) + '\n';
 		if (fitResult.elapsedTime > 1000)
 			str += i18n("calculation time: %1 s", fitResult.elapsedTime/1000) + '\n';
 		else
 			str += i18n("calculation time: %1 ms", fitResult.elapsedTime) + '\n';
 		str += i18n("degrees of freedom:") + ' ' + QString::number(fitResult.dof) + '\n';
 		str += i18n("number of parameters:") + ' ' + QString::number(fitResult.paramValues.size()) + '\n';
 		str += i18n("fit range:") + ' ' + QString::number(m_fitData.fitRange.first()) + " .. " + QString::number(m_fitData.fitRange.last()) + '\n';
 
 		str += i18n("Iterations:") + '\n';
-		for (const auto &s: m_fitData.paramNamesUtf8)
+		for (const auto &s : m_fitData.paramNamesUtf8)
 			str += s + '\t';
 		str += UTF8_QSTRING("χ²");
 
 		const QStringList iterations = fitResult.solverOutput.split(';');
-		for (const auto &s: iterations)
+		for (const auto &s : iterations)
 			if (!s.isEmpty())
 				str += '\n' + s;
 	}
 
 	QApplication::clipboard()->setText(str);
 	DEBUG(QApplication::clipboard()->text().toStdString());
 }
 
 void XYFitCurveDock::resultParametersContextMenuRequest(QPoint pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction(i18n("Copy Selection"), this, SLOT(resultCopySelection()));
 	contextMenu->addAction(i18n("Copy All"), this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twParameters->mapToGlobal(pos));
 }
 void XYFitCurveDock::resultGoodnessContextMenuRequest(QPoint pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction(i18n("Copy Selection"), this, SLOT(resultCopySelection()));
 	contextMenu->addAction(i18n("Copy All"), this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twGoodness->mapToGlobal(pos));
 }
 void XYFitCurveDock::resultLogContextMenuRequest(QPoint pos) {
 	QMenu *contextMenu = new QMenu;
 	contextMenu->addAction(i18n("Copy Selection"), this, SLOT(resultCopySelection()));
 	contextMenu->addAction(i18n("Copy All"), this, SLOT(resultCopyAll()));
 	contextMenu->exec(uiGeneralTab.twLog->mapToGlobal(pos));
 }
 
 			 /*!
  * show the result and details of fit
  */
 void XYFitCurveDock::showFitResult() {
 	DEBUG("XYFitCurveDock::showFitResult()");
 
 	//clear the previous result
 	uiGeneralTab.twParameters->setRowCount(0);
 	for (int row = 0; row < uiGeneralTab.twGoodness->rowCount(); ++row)
 		uiGeneralTab.twGoodness->item(row, 2)->setText("");
 	for (int row = 0; row < uiGeneralTab.twLog->rowCount(); ++row)
 		uiGeneralTab.twLog->item(row, 1)->setText("");
 
 	const XYFitCurve::FitResult& fitResult = m_fitCurve->fitResult();
 
 	if (!fitResult.available) {
 		DEBUG("fit result not available");
 		return;
 	}
 
 	// Log
 	uiGeneralTab.twLog->item(0, 1)->setText(fitResult.status);
 
 	if (!fitResult.valid) {
 		DEBUG("fit result not valid");
 		return;
 	}
 
 	uiGeneralTab.twLog->item(1, 1)->setText(QString::number(fitResult.iterations));
 	uiGeneralTab.twLog->item(2, 1)->setText(QString::number(m_fitData.eps));
 	if (fitResult.elapsedTime > 1000)
 		uiGeneralTab.twLog->item(3, 1)->setText(QString::number(fitResult.elapsedTime/1000) + " s");
 	else
 		uiGeneralTab.twLog->item(3, 1)->setText(QString::number(fitResult.elapsedTime) + " ms");
 
 	uiGeneralTab.twLog->item(4, 1)->setText(QString::number(fitResult.dof));
 	uiGeneralTab.twLog->item(5, 1)->setText(QString::number(fitResult.paramValues.size()));
 	uiGeneralTab.twLog->item(6, 1)->setText(QString::number(m_fitData.fitRange.first()) + " .. " + QString::number(m_fitData.fitRange.last()) );
 
 	// show all iterations
 	QString str;
-	for (const auto &s: m_fitData.paramNamesUtf8)
+	for (const auto &s : m_fitData.paramNamesUtf8)
 		str += s + '\t';
 	str += UTF8_QSTRING("χ²");
 
 	const QStringList iterations = fitResult.solverOutput.split(';');
-	for (const auto &s: iterations)
+	for (const auto &s : iterations)
 		if (!s.isEmpty())
 			str += '\n' + s;
 	uiGeneralTab.twLog->item(7, 1)->setText(str);
 	uiGeneralTab.twLog->resizeRowsToContents();
 
 	// Parameters
 	const int np = m_fitData.paramNames.size();
 	uiGeneralTab.twParameters->setRowCount(np);
 	QStringList headerLabels;
 	headerLabels << i18n("Name") << i18n("Value") << i18n("Error") << i18n("Error, %") << i18n("t statistic") << QLatin1String("P > |t|") << i18n("Conf. Interval");
 	uiGeneralTab.twParameters->setHorizontalHeaderLabels(headerLabels);
 
 	for (int i = 0; i < np; i++) {
 		const double paramValue = fitResult.paramValues.at(i);
 		const double errorValue = fitResult.errorValues.at(i);
 
 		QTableWidgetItem* item = new QTableWidgetItem(m_fitData.paramNamesUtf8.at(i));
 		item->setBackground(QApplication::palette().color(QPalette::Window));
 		uiGeneralTab.twParameters->setItem(i, 0, item);
 		item = new QTableWidgetItem(QString::number(paramValue));
 		uiGeneralTab.twParameters->setItem(i, 1, item);
 
 		if (!m_fitData.paramFixed.at(i)) {
 			if (!std::isnan(errorValue)) {
 				item = new QTableWidgetItem(QString::number(errorValue, 'g', 6));
 				uiGeneralTab.twParameters->setItem(i, 2, item);
 				item = new QTableWidgetItem(QString::number(100.*errorValue/std::abs(paramValue), 'g', 3));
 				uiGeneralTab.twParameters->setItem(i, 3, item);
 			} else {
 				item = new QTableWidgetItem(UTF8_QSTRING("∞"));
 				uiGeneralTab.twParameters->setItem(i, 2, item);
 				item = new QTableWidgetItem(UTF8_QSTRING("∞"));
 				uiGeneralTab.twParameters->setItem(i, 3, item);
 			}
 
 			// t values
 			QString tdistValueString;
 			if (fitResult.tdist_tValues.at(i) < std::numeric_limits<double>::max())
 				tdistValueString = QString::number(fitResult.tdist_tValues.at(i), 'g', 3);
 			else
 				tdistValueString = UTF8_QSTRING("∞");
 			item = new QTableWidgetItem(tdistValueString);
 			uiGeneralTab.twParameters->setItem(i, 4, item);
 
 			// p values
 			const double p = fitResult.tdist_pValues.at(i);
 			item = new QTableWidgetItem(QString::number(p, 'g', 3));
 			// color p values depending on value
 			if (p > 0.05)
 				item->setTextColor(QApplication::palette().color(QPalette::LinkVisited));
 			else if (p > 0.01)
 				item->setTextColor(Qt::darkGreen);
 			else if (p > 0.001)
 				item->setTextColor(Qt::darkCyan);
 			else if (p > 0.0001)
 				item->setTextColor(QApplication::palette().color(QPalette::Link));
 			else
 				item->setTextColor(QApplication::palette().color(QPalette::Highlight));
 			uiGeneralTab.twParameters->setItem(i, 5, item);
 
 			// Conf. interval
 			if (!std::isnan(errorValue)) {
 				const double margin = fitResult.tdist_marginValues.at(i);
 				if (fitResult.tdist_tValues.at(i) < 1.e6)
 					item = new QTableWidgetItem(QString::number(paramValue - margin) + QLatin1String(" .. ") + QString::number(paramValue + margin));
 				else
 					item = new QTableWidgetItem(i18n("too small"));
 				uiGeneralTab.twParameters->setItem(i, 6, item);
 			}
 		}
 	}
 
 	// Goodness of fit
 	uiGeneralTab.twGoodness->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
 	uiGeneralTab.twGoodness->item(0, 2)->setText(QString::number(fitResult.sse));
 
 	if (fitResult.dof != 0) {
 		uiGeneralTab.twGoodness->item(1, 2)->setText(QString::number(fitResult.rms));
 		uiGeneralTab.twGoodness->item(2, 2)->setText(QString::number(fitResult.rsd));
 
 		uiGeneralTab.twGoodness->item(3, 2)->setText(QString::number(fitResult.rsquare, 'g', 15));
 		uiGeneralTab.twGoodness->item(4, 2)->setText(QString::number(fitResult.rsquareAdj, 'g', 15));
 
 		// chi^2 and F test p-values
 		uiGeneralTab.twGoodness->item(5, 2)->setText(QString::number(fitResult.chisq_p, 'g', 3));
 		uiGeneralTab.twGoodness->item(6, 2)->setText(QString::number(fitResult.fdist_F, 'g', 3));
 		uiGeneralTab.twGoodness->item(7, 2)->setText(QString::number(fitResult.fdist_p, 'g', 3));
 		uiGeneralTab.twGoodness->item(9, 2)->setText(QString::number(fitResult.aic, 'g', 3));
 		uiGeneralTab.twGoodness->item(10, 2)->setText(QString::number(fitResult.bic, 'g', 3));
 	}
 
 	uiGeneralTab.twGoodness->item(8, 2)->setText(QString::number(fitResult.mae));
 
 	//resize the table headers to fit the new content
 	uiGeneralTab.twLog->resizeColumnsToContents();
 	uiGeneralTab.twParameters->resizeColumnsToContents();
 	//twGoodness doesn't have any header -> resize sections
 	uiGeneralTab.twGoodness->resizeColumnToContents(0);
 	uiGeneralTab.twGoodness->resizeColumnToContents(1);
 	uiGeneralTab.twGoodness->resizeColumnToContents(2);
 
 	//enable the "recalculate"-button if the source data was changed since the last fit
 	uiGeneralTab.pbRecalculate->setEnabled(m_fitCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYFitCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveXErrorColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXErrorColumn, column);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::curveYErrorColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYErrorColumn, column);
 	m_initializing = false;
 }
 
 /*!
  * called when fit data of fit curve changes
  */
 void XYFitCurveDock::curveFitDataChanged(const XYFitCurve::FitData& fitData) {
 	DEBUG("XYFitCurveDock::curveFitDataChanged()");
 	m_initializing = true;
 	m_fitData = fitData;
 
 	if (m_fitData.modelCategory != nsl_fit_model_custom)
 		uiGeneralTab.cbModel->setCurrentIndex(m_fitData.modelType);
 
 	uiGeneralTab.sbDegree->setValue(m_fitData.degree);
 	m_initializing = false;
 }
 
 void XYFitCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYIntegrationCurveDock.cpp b/src/kdefrontend/dockwidgets/XYIntegrationCurveDock.cpp
index 5f0d86929..e287263dc 100644
--- a/src/kdefrontend/dockwidgets/XYIntegrationCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYIntegrationCurveDock.cpp
@@ -1,504 +1,504 @@
 /***************************************************************************
     File             : XYIntegrationCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Description      : widget for editing properties of integration curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYIntegrationCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYIntegrationCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 
 extern "C" {
 #include "backend/nsl/nsl_int.h"
 }
 
 /*!
   \class XYIntegrationCurveDock
  \brief  Provides a widget for editing the properties of the XYIntegrationCurves
 		(2D-curves defined by a integration) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYIntegrationCurveDock::XYIntegrationCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_integrationCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYIntegrationCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
-	auto gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 3);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 3);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 3);
 
 	for (int i = 0; i < NSL_INT_NETHOD_COUNT; i++)
 		uiGeneralTab.cbMethod->addItem(i18n(nsl_int_method_name[i]));
 
 	uiGeneralTab.sbMin->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbMax->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYIntegrationCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYIntegrationCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbMethod, SIGNAL(currentIndexChanged(int)), this, SLOT(methodChanged()) );
 	connect( uiGeneralTab.cbAbsolute, SIGNAL(clicked(bool)), this, SLOT(absoluteChanged()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYIntegrationCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_integrationCurve = dynamic_cast<XYIntegrationCurve*>(m_curve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_integrationCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_integrationCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_integrationCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_integrationCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_integrationData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_integrationData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_integrationData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbMethod->setCurrentIndex(m_integrationData.method);
 	this->methodChanged();
 	uiGeneralTab.cbAbsolute->setChecked(m_integrationData.absolute);
 	this->absoluteChanged();
 
 	this->showIntegrationResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_integrationCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_integrationCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_integrationCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_integrationCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_integrationCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_integrationCurve, SIGNAL(integrationDataChanged(XYIntegrationCurve::IntegrationData)), this, SLOT(curveIntegrationDataChanged(XYIntegrationCurve::IntegrationData)));
 	connect(m_integrationCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYIntegrationCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve : m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbDataSourceCurve->setModel(m_aspectTreeModel);
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYIntegrationCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_integrationCurve = dynamic_cast<XYIntegrationCurve*>(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_integrationData = m_integrationCurve->integrationData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYIntegrationCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYIntegrationCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYIntegrationCurveDock::dataSourceTypeChanged(int index) {
 	const auto type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYIntegrationCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYIntegrationCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 
 	// disable integration orders and accuracies that need more data points
 	this->updateSettings(dataSourceCurve->xColumn());
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYIntegrationCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYIntegrationCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYIntegrationCurve*>(curve)->setXDataColumn(column);
 
 	if (column != nullptr) {
 		if (uiGeneralTab.cbAutoRange->isChecked()) {
 			uiGeneralTab.sbMin->setValue(column->minimum());
 			uiGeneralTab.sbMax->setValue(column->maximum());
 		}
 
 		// disable integration methods that need more data points
 		this->updateSettings(column);
 	}
 }
 
 /*!
  * disable deriv orders and accuracies that need more data points
  */
 void XYIntegrationCurveDock::updateSettings(const AbstractColumn* column) {
 	if (!column)
 		return;
 
 	//TODO
 // 	size_t n=0;
 // 	for (int row=0; row < column->rowCount(); row++)
 // 		if (!std::isnan(column->valueAt(row)) && !column->isMasked(row))
 // 			n++;
 }
 void XYIntegrationCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
-	auto column = dynamic_cast<AbstractColumn*>(aspect);
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYIntegrationCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYIntegrationCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_integrationData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = nullptr;
 		if (m_integrationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet)
 			xDataColumn = m_integrationCurve->xDataColumn();
 		else {
 			if (m_integrationCurve->dataSourceCurve())
 				xDataColumn = m_integrationCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYIntegrationCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_integrationData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYIntegrationCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_integrationData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYIntegrationCurveDock::methodChanged() {
 	const auto method = (nsl_int_method_type)uiGeneralTab.cbMethod->currentIndex();
 	m_integrationData.method = method;
 
 	// update absolute option
 	switch (method) {
 	case nsl_int_method_rectangle:
 	case nsl_int_method_trapezoid:
 		uiGeneralTab.cbAbsolute->setEnabled(true);
 		break;
 	case nsl_int_method_simpson:
 	case nsl_int_method_simpson_3_8:
 		uiGeneralTab.cbAbsolute->setChecked(false);
 		uiGeneralTab.cbAbsolute->setEnabled(false);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYIntegrationCurveDock::absoluteChanged() {
 	bool absolute = uiGeneralTab.cbAbsolute->isChecked();
 	m_integrationData.absolute = absolute;
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYIntegrationCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYIntegrationCurve*>(curve)->setIntegrationData(m_integrationData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Integration status: %1", m_integrationCurve->integrationResult().status));
 	QApplication::restoreOverrideCursor();
 }
 
 void XYIntegrationCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no integration possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_integrationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=nullptr && aspectY!=nullptr);
 	} else {
 		 hasSourceData = (m_integrationCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the integration
  */
 void XYIntegrationCurveDock::showIntegrationResult() {
 	const XYIntegrationCurve::IntegrationResult& integrationResult = m_integrationCurve->integrationResult();
 	if (!integrationResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status: %1", integrationResult.status) + "<br>";
 
 	if (!integrationResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (integrationResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s", QString::number(integrationResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms", QString::number(integrationResult.elapsedTime)) + "<br>";
 
 	str += i18n("value: %1", QString::number(integrationResult.value)) + "<br>";
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last integration
 	uiGeneralTab.pbRecalculate->setEnabled(m_integrationCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYIntegrationCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::curveIntegrationDataChanged(const XYIntegrationCurve::IntegrationData& integrationData) {
 	m_initializing = true;
 	m_integrationData = integrationData;
 	uiGeneralTab.cbMethod->setCurrentIndex(m_integrationData.method);
 	this->methodChanged();
 	uiGeneralTab.cbAbsolute->setChecked(m_integrationData.absolute);
 	this->absoluteChanged();
 
 	this->showIntegrationResult();
 	m_initializing = false;
 }
 
 void XYIntegrationCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYInterpolationCurveDock.cpp b/src/kdefrontend/dockwidgets/XYInterpolationCurveDock.cpp
index 1f0265e9c..021d7a1af 100644
--- a/src/kdefrontend/dockwidgets/XYInterpolationCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYInterpolationCurveDock.cpp
@@ -1,735 +1,735 @@
 /***************************************************************************
     File             : XYInterpolationCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 20016-2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of interpolation curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYInterpolationCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYInterpolationCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 
 extern "C" {
 #include <gsl/gsl_interp.h>	// gsl_interp types
 }
 #include <cmath>        // isnan
 
 /*!
   \class XYInterpolationCurveDock
  \brief  Provides a widget for editing the properties of the XYInterpolationCurves
 		(2D-curves defined by an interpolation) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYInterpolationCurveDock::XYInterpolationCurveDock(QWidget* parent): XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_interpolationCurve(nullptr),
 	dataPoints(0) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYInterpolationCurveDock::setupGeneral() {
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
-	auto gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
+	auto* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 2);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 2);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 2);
 
-	for (int i=0; i < NSL_INTERP_TYPE_COUNT; i++)
+	for (int i = 0; i < NSL_INTERP_TYPE_COUNT; i++)
 		uiGeneralTab.cbType->addItem(i18n(nsl_interp_type_name[i]));
 #if GSL_MAJOR_VERSION < 2
 	// disable Steffen spline item
 	const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbType->model());
 	QStandardItem* item = model->item(nsl_interp_type_steffen);
 	item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 #endif
-	for (int i=0; i < NSL_INTERP_PCH_VARIANT_COUNT; i++)
+	for (int i = 0; i < NSL_INTERP_PCH_VARIANT_COUNT; i++)
 		uiGeneralTab.cbVariant->addItem(i18n(nsl_interp_pch_variant_name[i]));
-	for (int i=0; i < NSL_INTERP_EVALUATE_COUNT; i++)
+	for (int i = 0; i < NSL_INTERP_EVALUATE_COUNT; i++)
 		uiGeneralTab.cbEval->addItem(i18n(nsl_interp_evaluate_name[i]));
 
 	uiGeneralTab.cbPointsMode->addItem(i18n("Auto (5x data points)"));
 	uiGeneralTab.cbPointsMode->addItem(i18n("Multiple of data points"));
 	uiGeneralTab.cbPointsMode->addItem(i18n("Custom"));
 
 	uiGeneralTab.sbMin->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbMax->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
-	auto layout = new QHBoxLayout(ui.tabGeneral);
+	auto* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYInterpolationCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYInterpolationCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.cbVariant, SIGNAL(currentIndexChanged(int)), this, SLOT(variantChanged()) );
 	connect( uiGeneralTab.sbTension, SIGNAL(valueChanged(double)), this, SLOT(tensionChanged()) );
 	connect( uiGeneralTab.sbContinuity, SIGNAL(valueChanged(double)), this, SLOT(continuityChanged()) );
 	connect( uiGeneralTab.sbBias, SIGNAL(valueChanged(double)), this, SLOT(biasChanged()) );
 	connect( uiGeneralTab.cbEval, SIGNAL(currentIndexChanged(int)), this, SLOT(evaluateChanged()) );
 	connect( uiGeneralTab.sbPoints, SIGNAL(valueChanged(double)), this, SLOT(numberOfPointsChanged()) );
 	connect( uiGeneralTab.cbPointsMode, SIGNAL(currentIndexChanged(int)), this, SLOT(pointsModeChanged()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYInterpolationCurveDock::initGeneralTab() {
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_interpolationCurve = dynamic_cast<XYInterpolationCurve*>(m_curve);
 	Q_ASSERT(m_interpolationCurve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_interpolationCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_interpolationCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_interpolationCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_interpolationCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_interpolationData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_interpolationData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_interpolationData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbType->setCurrentIndex(m_interpolationData.type);
 	this->typeChanged();
 	uiGeneralTab.cbVariant->setCurrentIndex(m_interpolationData.variant);
 	this->variantChanged();
 	uiGeneralTab.sbTension->setValue(m_interpolationData.tension);
 	uiGeneralTab.sbContinuity->setValue(m_interpolationData.continuity);
 	uiGeneralTab.sbBias->setValue(m_interpolationData.bias);
 	uiGeneralTab.cbEval->setCurrentIndex(m_interpolationData.evaluate);
 
 	if (m_interpolationData.pointsMode == XYInterpolationCurve::Multiple)
 		uiGeneralTab.sbPoints->setValue(m_interpolationData.npoints/5.);
 	else
 		uiGeneralTab.sbPoints->setValue(m_interpolationData.npoints);
 	uiGeneralTab.cbPointsMode->setCurrentIndex(m_interpolationData.pointsMode);
 
 	this->showInterpolationResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_interpolationCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_interpolationCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_interpolationCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_interpolationCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_interpolationCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_interpolationCurve, SIGNAL(interpolationDataChanged(XYInterpolationCurve::InterpolationData)), this, SLOT(curveInterpolationDataChanged(XYInterpolationCurve::InterpolationData)));
 	connect(m_interpolationCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYInterpolationCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for(XYCurve* curve: m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve"<<"CantorWorksheet";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYInterpolationCurveDock::setCurves(QList<XYCurve*> list) {
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_interpolationCurve = dynamic_cast<XYInterpolationCurve*>(m_curve);
 	Q_ASSERT(m_interpolationCurve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_interpolationData = m_interpolationCurve->interpolationData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYInterpolationCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYInterpolationCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYInterpolationCurveDock::dataSourceTypeChanged(int index) {
 	const auto type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYInterpolationCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYInterpolationCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = nullptr;
 	if (aspect) {
 		dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 		Q_ASSERT(dataSourceCurve);
 	}
 
 	// disable types that need more data points
 	this->updateSettings(dataSourceCurve->xColumn());
 
 	if (m_initializing)
 		return;
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYInterpolationCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYInterpolationCurveDock::xDataColumnChanged(const QModelIndex& index) {
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = nullptr;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	this->updateSettings(column);
 
 	if (m_initializing)
 		return;
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYInterpolationCurve*>(curve)->setXDataColumn(column);
 }
 
 void XYInterpolationCurveDock::updateSettings(const AbstractColumn* column) {
 	if (!column)
 		return;
 
 	// disable types that need more data points
 	if (uiGeneralTab.cbAutoRange->isChecked()) {
 		uiGeneralTab.sbMin->setValue(column->minimum());
 		uiGeneralTab.sbMax->setValue(column->maximum());
 	}
 
 	unsigned int n = 0;
 	for (int row = 0; row < column->rowCount(); row++)
 		if (!std::isnan(column->valueAt(row)) && !column->isMasked(row))
 			n++;
 	dataPoints = n;
 	if(m_interpolationData.pointsMode == XYInterpolationCurve::Auto)
 		pointsModeChanged();
 
-	const auto model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbType->model());
+	const auto* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbType->model());
 	QStandardItem* item = model->item(nsl_interp_type_polynomial);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_polynomial) || dataPoints > 100) {	// not good for many points
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_polynomial)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_interp_type_cspline);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_cspline)) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_cspline)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_interp_type_cspline_periodic);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_cspline_periodic)) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_cspline_periodic)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_interp_type_akima);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_akima)) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_akima)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 	item = model->item(nsl_interp_type_akima_periodic);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_akima_periodic)) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_akima_periodic)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 
 #if GSL_MAJOR_VERSION >= 2
 	item = model->item(nsl_interp_type_steffen);
 	if (dataPoints < gsl_interp_type_min_size(gsl_interp_steffen)) {
 		item->setFlags(item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 		if (uiGeneralTab.cbType->currentIndex() == nsl_interp_type_steffen)
 			uiGeneralTab.cbType->setCurrentIndex(0);
 	}
 	else
 		item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 #endif
 	// own types work with 2 or more data points
 }
 
 void XYInterpolationCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
-	auto aspect = static_cast<AbstractAspect*>(index.internalPointer());
+	auto* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = nullptr;
 	if (aspect) {
 		column = dynamic_cast<AbstractColumn*>(aspect);
 		Q_ASSERT(column);
 	}
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYInterpolationCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYInterpolationCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_interpolationData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = nullptr;
 		if (m_interpolationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet)
 			xDataColumn = m_interpolationCurve->xDataColumn();
 		else {
 			if (m_interpolationCurve->dataSourceCurve())
 				xDataColumn = m_interpolationCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYInterpolationCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_interpolationData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_interpolationData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::typeChanged() {
 	const auto type = (nsl_interp_type)uiGeneralTab.cbType->currentIndex();
 	m_interpolationData.type = type;
 
 	switch (type) {
 	case nsl_interp_type_pch:
 		uiGeneralTab.lVariant->show();
 		uiGeneralTab.cbVariant->show();
 		break;
 	case nsl_interp_type_linear:
 	case nsl_interp_type_polynomial:
 	case nsl_interp_type_cspline:
 	case nsl_interp_type_cspline_periodic:
 	case nsl_interp_type_akima:
 	case nsl_interp_type_akima_periodic:
 	case nsl_interp_type_steffen:
 	case nsl_interp_type_cosine:
 	case nsl_interp_type_exponential:
 	case nsl_interp_type_rational:
 		uiGeneralTab.lVariant->hide();
 		uiGeneralTab.cbVariant->hide();
 		uiGeneralTab.cbVariant->setCurrentIndex(nsl_interp_pch_variant_finite_difference);
 		uiGeneralTab.lParameter->hide();
 		uiGeneralTab.lTension->hide();
 		uiGeneralTab.sbTension->hide();
 		uiGeneralTab.lContinuity->hide();
 		uiGeneralTab.sbContinuity->hide();
 		uiGeneralTab.lBias->hide();
 		uiGeneralTab.sbBias->hide();
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::variantChanged() {
 	const auto variant = (nsl_interp_pch_variant)uiGeneralTab.cbVariant->currentIndex();
 	m_interpolationData.variant = variant;
 
 	switch (variant) {
 	case nsl_interp_pch_variant_finite_difference:
 		uiGeneralTab.lParameter->hide();
                 uiGeneralTab.lTension->hide();
                 uiGeneralTab.sbTension->hide();
                 uiGeneralTab.lContinuity->hide();
                 uiGeneralTab.sbContinuity->hide();
                 uiGeneralTab.lBias->hide();
                 uiGeneralTab.sbBias->hide();
 		break;
 	case nsl_interp_pch_variant_catmull_rom:
 		uiGeneralTab.lParameter->show();
                 uiGeneralTab.lTension->show();
                 uiGeneralTab.sbTension->show();
                 uiGeneralTab.sbTension->setEnabled(false);
                 uiGeneralTab.sbTension->setValue(0.0);
                 uiGeneralTab.lContinuity->hide();
                 uiGeneralTab.sbContinuity->hide();
                 uiGeneralTab.lBias->hide();
                 uiGeneralTab.sbBias->hide();
 		break;
 	case nsl_interp_pch_variant_cardinal:
 		uiGeneralTab.lParameter->show();
                 uiGeneralTab.lTension->show();
                 uiGeneralTab.sbTension->show();
                 uiGeneralTab.sbTension->setEnabled(true);
                 uiGeneralTab.lContinuity->hide();
                 uiGeneralTab.sbContinuity->hide();
                 uiGeneralTab.lBias->hide();
                 uiGeneralTab.sbBias->hide();
 		break;
 	case nsl_interp_pch_variant_kochanek_bartels:
 		uiGeneralTab.lParameter->show();
                 uiGeneralTab.lTension->show();
                 uiGeneralTab.sbTension->show();
                 uiGeneralTab.sbTension->setEnabled(true);
                 uiGeneralTab.lContinuity->show();
                 uiGeneralTab.sbContinuity->show();
                 uiGeneralTab.lBias->show();
                 uiGeneralTab.sbBias->show();
 		break;
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::tensionChanged() {
 	m_interpolationData.tension = uiGeneralTab.sbTension->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::continuityChanged() {
 	m_interpolationData.continuity = uiGeneralTab.sbContinuity->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::biasChanged() {
 	m_interpolationData.bias = uiGeneralTab.sbBias->value();
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::evaluateChanged() {
 	m_interpolationData.evaluate = (nsl_interp_evaluate)uiGeneralTab.cbEval->currentIndex();
 
 
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYInterpolationCurveDock::pointsModeChanged() {
 	const auto mode = (XYInterpolationCurve::PointsMode)uiGeneralTab.cbPointsMode->currentIndex();
 
 	switch (mode) {
 	case XYInterpolationCurve::Auto:
 		uiGeneralTab.sbPoints->setEnabled(false);
 		uiGeneralTab.sbPoints->setDecimals(0);
 		uiGeneralTab.sbPoints->setSingleStep(1.0);
 		uiGeneralTab.sbPoints->setValue(5*dataPoints);
 		break;
 	case XYInterpolationCurve::Multiple:
 		uiGeneralTab.sbPoints->setEnabled(true);
 		if(m_interpolationData.pointsMode != XYInterpolationCurve::Multiple && dataPoints > 0) {
 			uiGeneralTab.sbPoints->setDecimals(2);
 			uiGeneralTab.sbPoints->setValue(uiGeneralTab.sbPoints->value()/(double)dataPoints);
 			uiGeneralTab.sbPoints->setSingleStep(0.01);
 		}
 		break;
 	case XYInterpolationCurve::Custom:
 		uiGeneralTab.sbPoints->setEnabled(true);
 		if(m_interpolationData.pointsMode == XYInterpolationCurve::Multiple) {
 			uiGeneralTab.sbPoints->setDecimals(0);
 			uiGeneralTab.sbPoints->setSingleStep(1.0);
 			uiGeneralTab.sbPoints->setValue(uiGeneralTab.sbPoints->value()*dataPoints);
 		}
 		break;
 	}
 
 	m_interpolationData.pointsMode = mode;
 }
 
 void XYInterpolationCurveDock::numberOfPointsChanged() {
 	if(uiGeneralTab.cbPointsMode->currentIndex() == XYInterpolationCurve::Multiple)
 		m_interpolationData.npoints = uiGeneralTab.sbPoints->value()*dataPoints;
 	else
 		m_interpolationData.npoints = uiGeneralTab.sbPoints->value();
 
 	// warn if points is smaller than data points
 	QPalette palette = uiGeneralTab.sbPoints->palette();
 	if(m_interpolationData.npoints < dataPoints)
 		palette.setColor(QPalette::Text, Qt::red);
 	else
 		palette.setColor(QPalette::Text, Qt::black);
 	uiGeneralTab.sbPoints->setPalette(palette);
 
 	enableRecalculate();
 }
 
 void XYInterpolationCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for(XYCurve* curve: m_curvesList)
 		dynamic_cast<XYInterpolationCurve*>(curve)->setInterpolationData(m_interpolationData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Interpolation status: %1", m_interpolationCurve->interpolationResult().status));
 	QApplication::restoreOverrideCursor();
 }
 
 void XYInterpolationCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no interpolation possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_interpolationCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=nullptr && aspectY!=nullptr);
 	} else {
 		 hasSourceData = (m_interpolationCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the interpolation
  */
 void XYInterpolationCurveDock::showInterpolationResult() {
 	const XYInterpolationCurve::InterpolationResult& interpolationResult = m_interpolationCurve->interpolationResult();
 	if (!interpolationResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	QString str = i18n("status: %1", interpolationResult.status) + "<br>";
 
 	if (!interpolationResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (interpolationResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s", QString::number(interpolationResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms", QString::number(interpolationResult.elapsedTime)) + "<br>";
 
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last interpolation
 	uiGeneralTab.pbRecalculate->setEnabled(m_interpolationCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYInterpolationCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text()) {
 		uiGeneralTab.leName->setText(aspect->name());
 	} else if (aspect->comment() != uiGeneralTab.leComment->text()) {
 		uiGeneralTab.leComment->setText(aspect->comment());
 	}
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::curveInterpolationDataChanged(const XYInterpolationCurve::InterpolationData& data) {
 	m_initializing = true;
 	m_interpolationData = data;
 	uiGeneralTab.cbType->setCurrentIndex(m_interpolationData.type);
 	this->typeChanged();
 
 	this->showInterpolationResult();
 	m_initializing = false;
 }
 
 void XYInterpolationCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp b/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
index 6f7ff578e..62ca52fb9 100644
--- a/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
+++ b/src/kdefrontend/dockwidgets/XYSmoothCurveDock.cpp
@@ -1,593 +1,593 @@
 /***************************************************************************
     File             : XYSmoothCurveDock.cpp
     Project          : LabPlot
     --------------------------------------------------------------------
     Copyright        : (C) 2016 Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright        : (C) 2017 Alexander Semke (alexander.semke@web.de)
     Description      : widget for editing properties of smooth curves
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "XYSmoothCurveDock.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/XYSmoothCurve.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QStandardItemModel>
 
 /*!
   \class XYSmoothCurveDock
  \brief  Provides a widget for editing the properties of the XYSmoothCurves
 		(2D-curves defined by an smooth) currently selected in
 		the project explorer.
 
   If more then one curves are set, the properties of the first column are shown.
   The changes of the properties are applied to all curves.
   The exclusions are the name, the comment and the datasets (columns) of
   the curves  - these properties can only be changed if there is only one single curve.
 
   \ingroup kdefrontend
 */
 
 XYSmoothCurveDock::XYSmoothCurveDock(QWidget* parent) : XYCurveDock(parent),
 	cbDataSourceCurve(nullptr),
 	cbXDataColumn(nullptr),
 	cbYDataColumn(nullptr),
 	m_smoothCurve(nullptr) {
 
 	//hide the line connection type
 	ui.cbLineType->setDisabled(true);
 
 	//remove the tab "Error bars"
 	ui.tabWidget->removeTab(5);
 }
 
 /*!
  * 	// Tab "General"
  */
 void XYSmoothCurveDock::setupGeneral() {
 	DEBUG("XYSmoothCurveDock::setupGeneral()");
 
 	QWidget* generalTab = new QWidget(ui.tabGeneral);
 	uiGeneralTab.setupUi(generalTab);
 
 	QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(generalTab->layout());
 	if (gridLayout) {
 		gridLayout->setContentsMargins(2,2,2,2);
 		gridLayout->setHorizontalSpacing(2);
 		gridLayout->setVerticalSpacing(2);
 	}
 
 	uiGeneralTab.cbDataSourceType->addItem(i18n("Spreadsheet"));
 	uiGeneralTab.cbDataSourceType->addItem(i18n("XY-Curve"));
 
 	cbDataSourceCurve = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbDataSourceCurve, 5, 2, 1, 2);
 	cbXDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbXDataColumn, 6, 2, 1, 2);
 	cbYDataColumn = new TreeViewComboBox(generalTab);
 	gridLayout->addWidget(cbYDataColumn, 7, 2, 1, 2);
 
-	for (int i=0; i < NSL_SMOOTH_TYPE_COUNT; i++)
+	for (int i = 0; i < NSL_SMOOTH_TYPE_COUNT; i++)
 		uiGeneralTab.cbType->addItem(i18n(nsl_smooth_type_name[i]));
 
-	for (int i=0; i < NSL_SMOOTH_WEIGHT_TYPE_COUNT; i++)
+	for (int i = 0; i < NSL_SMOOTH_WEIGHT_TYPE_COUNT; i++)
 		uiGeneralTab.cbWeight->addItem(i18n(nsl_smooth_weight_type_name[i]));
 
-	for (int i=0; i < NSL_SMOOTH_PAD_MODE_COUNT; i++)
+	for (int i = 0; i < NSL_SMOOTH_PAD_MODE_COUNT; i++)
 		uiGeneralTab.cbMode->addItem(i18n(nsl_smooth_pad_mode_name[i]));
 
 	uiGeneralTab.sbMin->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 	uiGeneralTab.sbMax->setRange(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max());
 
 	uiGeneralTab.pbRecalculate->setIcon(QIcon::fromTheme("run-build"));
 
 	QHBoxLayout* layout = new QHBoxLayout(ui.tabGeneral);
 	layout->setMargin(0);
 	layout->addWidget(generalTab);
 
 	//Slots
 	connect( uiGeneralTab.leName, &QLineEdit::textChanged, this, &XYSmoothCurveDock::nameChanged );
 	connect( uiGeneralTab.leComment, &QLineEdit::textChanged, this, &XYSmoothCurveDock::commentChanged );
 	connect( uiGeneralTab.chkVisible, SIGNAL(clicked(bool)), this, SLOT(visibilityChanged(bool)) );
 	connect( uiGeneralTab.cbDataSourceType, SIGNAL(currentIndexChanged(int)), this, SLOT(dataSourceTypeChanged(int)) );
 	connect( uiGeneralTab.cbAutoRange, SIGNAL(clicked(bool)), this, SLOT(autoRangeChanged()) );
 	connect( uiGeneralTab.sbMin, SIGNAL(valueChanged(double)), this, SLOT(xRangeMinChanged()) );
 	connect( uiGeneralTab.sbMax, SIGNAL(valueChanged(double)), this, SLOT(xRangeMaxChanged()) );
 	connect( uiGeneralTab.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged()) );
 	connect( uiGeneralTab.sbPoints, SIGNAL(valueChanged(int)), this, SLOT(pointsChanged()) );
 	connect( uiGeneralTab.cbWeight, SIGNAL(currentIndexChanged(int)), this, SLOT(weightChanged()) );
 	connect( uiGeneralTab.sbPercentile, SIGNAL(valueChanged(double)), this, SLOT(percentileChanged()) );
 	connect( uiGeneralTab.sbOrder, SIGNAL(valueChanged(int)), this, SLOT(orderChanged()) );
 	connect( uiGeneralTab.cbMode, SIGNAL(currentIndexChanged(int)), this, SLOT(modeChanged()) );
 	connect( uiGeneralTab.sbLeftValue, SIGNAL(valueChanged(double)), this, SLOT(valueChanged()) );
 	connect( uiGeneralTab.sbRightValue, SIGNAL(valueChanged(double)), this, SLOT(valueChanged()) );
 	connect( uiGeneralTab.pbRecalculate, SIGNAL(clicked()), this, SLOT(recalculateClicked()) );
 
 	connect( cbDataSourceCurve, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(dataSourceCurveChanged(QModelIndex)) );
 	connect( cbXDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(xDataColumnChanged(QModelIndex)) );
 	connect( cbYDataColumn, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(yDataColumnChanged(QModelIndex)) );
 }
 
 void XYSmoothCurveDock::initGeneralTab() {
 	DEBUG("XYSmoothCurveDock::initGeneralTab()");
 
 	//if there are more then one curve in the list, disable the tab "general"
 	if (m_curvesList.size()==1) {
 		uiGeneralTab.lName->setEnabled(true);
 		uiGeneralTab.leName->setEnabled(true);
 		uiGeneralTab.lComment->setEnabled(true);
 		uiGeneralTab.leComment->setEnabled(true);
 
 		uiGeneralTab.leName->setText(m_curve->name());
 		uiGeneralTab.leComment->setText(m_curve->comment());
 	}else {
 		uiGeneralTab.lName->setEnabled(false);
 		uiGeneralTab.leName->setEnabled(false);
 		uiGeneralTab.lComment->setEnabled(false);
 		uiGeneralTab.leComment->setEnabled(false);
 
 		uiGeneralTab.leName->setText("");
 		uiGeneralTab.leComment->setText("");
 	}
 
 	//show the properties of the first curve
 	m_smoothCurve = dynamic_cast<XYSmoothCurve*>(m_curve);
 
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(m_smoothCurve->dataSourceType());
 	this->dataSourceTypeChanged(uiGeneralTab.cbDataSourceType->currentIndex());
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, m_smoothCurve->dataSourceCurve());
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, m_smoothCurve->xDataColumn());
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, m_smoothCurve->yDataColumn());
 	uiGeneralTab.cbAutoRange->setChecked(m_smoothData.autoRange);
 	uiGeneralTab.sbMin->setValue(m_smoothData.xRange.first());
 	uiGeneralTab.sbMax->setValue(m_smoothData.xRange.last());
 	this->autoRangeChanged();
 	// update list of selectable types
 	xDataColumnChanged(cbXDataColumn->currentModelIndex());
 
 	uiGeneralTab.cbType->setCurrentIndex(m_smoothData.type);
 	typeChanged();	// needed, when type does not change
 	uiGeneralTab.sbPoints->setValue((int)m_smoothData.points);
 	uiGeneralTab.cbWeight->setCurrentIndex(m_smoothData.weight);
 	uiGeneralTab.sbPercentile->setValue(m_smoothData.percentile);
 	uiGeneralTab.sbOrder->setValue((int)m_smoothData.order);
 	uiGeneralTab.cbMode->setCurrentIndex(m_smoothData.mode);
 	modeChanged();	// needed, when mode does not change
 	uiGeneralTab.sbLeftValue->setValue(m_smoothData.lvalue);
 	uiGeneralTab.sbRightValue->setValue(m_smoothData.rvalue);
 	valueChanged();
 	this->showSmoothResult();
 
 	uiGeneralTab.chkVisible->setChecked( m_curve->isVisible() );
 
 	//Slots
 	connect(m_smoothCurve, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)), this, SLOT(curveDescriptionChanged(const AbstractAspect*)));
 	connect(m_smoothCurve, SIGNAL(dataSourceTypeChanged(XYAnalysisCurve::DataSourceType)), this, SLOT(curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType)));
 	connect(m_smoothCurve, SIGNAL(dataSourceCurveChanged(const XYCurve*)), this, SLOT(curveDataSourceCurveChanged(const XYCurve*)));
 	connect(m_smoothCurve, SIGNAL(xDataColumnChanged(const AbstractColumn*)), this, SLOT(curveXDataColumnChanged(const AbstractColumn*)));
 	connect(m_smoothCurve, SIGNAL(yDataColumnChanged(const AbstractColumn*)), this, SLOT(curveYDataColumnChanged(const AbstractColumn*)));
 	connect(m_smoothCurve, SIGNAL(smoothDataChanged(XYSmoothCurve::SmoothData)), this, SLOT(curveSmoothDataChanged(XYSmoothCurve::SmoothData)));
 	connect(m_smoothCurve, SIGNAL(sourceDataChanged()), this, SLOT(enableRecalculate()));
 }
 
 void XYSmoothCurveDock::setModel() {
 	QList<const char*>  list;
 	list<<"Folder"<<"Datapicker"<<"Worksheet"<<"CartesianPlot"<<"XYCurve";
 	cbDataSourceCurve->setTopLevelClasses(list);
 
 	QList<const AbstractAspect*> hiddenAspects;
 	for (auto* curve : m_curvesList)
 		hiddenAspects << curve;
 	cbDataSourceCurve->setHiddenAspects(hiddenAspects);
 
 	list.clear();
 	list<<"Folder"<<"Workbook"<<"Datapicker"<<"DatapickerCurve"<<"Spreadsheet"
 		<<"FileDataSource"<<"Column"<<"Worksheet"<<"CartesianPlot"<<"XYFitCurve"<<"CantorWorksheet";
 	cbXDataColumn->setTopLevelClasses(list);
 	cbYDataColumn->setTopLevelClasses(list);
 
 	cbXDataColumn->setModel(m_aspectTreeModel);
 	cbYDataColumn->setModel(m_aspectTreeModel);
 
 	XYCurveDock::setModel();
 }
 
 /*!
   sets the curves. The properties of the curves in the list \c list can be edited in this widget.
 */
 void XYSmoothCurveDock::setCurves(QList<XYCurve*> list) {
 	DEBUG("XYSmoothCurveDock::setCurves()");
 
 	m_initializing=true;
 	m_curvesList=list;
 	m_curve=list.first();
 	m_smoothCurve = dynamic_cast<XYSmoothCurve*>(m_curve);
 	m_aspectTreeModel = new AspectTreeModel(m_curve->project());
 	this->setModel();
 	m_smoothData = m_smoothCurve->smoothData();
 	initGeneralTab();
 	initTabs();
 	m_initializing=false;
 
 	//hide the "skip gaps" option after the curves were set
 	ui.lLineSkipGaps->hide();
 	ui.chkLineSkipGaps->hide();
 }
 
 //*************************************************************
 //**** SLOTs for changes triggered in XYFitCurveDock *****
 //*************************************************************
 void XYSmoothCurveDock::nameChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setName(uiGeneralTab.leName->text());
 }
 
 void XYSmoothCurveDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_curve->setComment(uiGeneralTab.leComment->text());
 }
 
 void XYSmoothCurveDock::dataSourceTypeChanged(int index) {
 	XYAnalysisCurve::DataSourceType type = (XYAnalysisCurve::DataSourceType)index;
 	if (type == XYAnalysisCurve::DataSourceSpreadsheet) {
 		uiGeneralTab.lDataSourceCurve->hide();
 		cbDataSourceCurve->hide();
 		uiGeneralTab.lXColumn->show();
 		cbXDataColumn->show();
 		uiGeneralTab.lYColumn->show();
 		cbYDataColumn->show();
 	} else {
 		uiGeneralTab.lDataSourceCurve->show();
 		cbDataSourceCurve->show();
 		uiGeneralTab.lXColumn->hide();
 		cbXDataColumn->hide();
 		uiGeneralTab.lYColumn->hide();
 		cbYDataColumn->hide();
 	}
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setDataSourceType(type);
 }
 
 void XYSmoothCurveDock::dataSourceCurveChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	XYCurve* dataSourceCurve = dynamic_cast<XYCurve*>(aspect);
 
 	if (m_initializing)
 		return;
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setDataSourceCurve(dataSourceCurve);
 }
 
 void XYSmoothCurveDock::xDataColumnChanged(const QModelIndex& index) {
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setXDataColumn(column);
 
 	// disable types that need more data points
 	if (column != nullptr) {
 		if (uiGeneralTab.cbAutoRange->isChecked()) {
 			uiGeneralTab.sbMin->setValue(column->minimum());
 			uiGeneralTab.sbMax->setValue(column->maximum());
 		}
 
 		unsigned int n = 0;
 		for (int row = 0; row < column->rowCount(); row++)
 			if (!std::isnan(column->valueAt(row)) && !column->isMasked(row))
 				n++;
 
 		// set maximum of sbPoints to number of columns
 		uiGeneralTab.sbPoints->setMaximum((int)n);
 	}
 
 }
 
 void XYSmoothCurveDock::yDataColumnChanged(const QModelIndex& index) {
 	if (m_initializing)
 		return;
 
 	AbstractAspect* aspect = static_cast<AbstractAspect*>(index.internalPointer());
 	AbstractColumn* column = dynamic_cast<AbstractColumn*>(aspect);
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setYDataColumn(column);
 }
 
 void XYSmoothCurveDock::autoRangeChanged() {
 	bool autoRange = uiGeneralTab.cbAutoRange->isChecked();
 	m_smoothData.autoRange = autoRange;
 
 	if (autoRange) {
 		uiGeneralTab.lMin->setEnabled(false);
 		uiGeneralTab.sbMin->setEnabled(false);
 		uiGeneralTab.lMax->setEnabled(false);
 		uiGeneralTab.sbMax->setEnabled(false);
 
 		const AbstractColumn* xDataColumn = nullptr;
 		if (m_smoothCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet)
 			xDataColumn = m_smoothCurve->xDataColumn();
 		else {
 			if (m_smoothCurve->dataSourceCurve())
 				xDataColumn = m_smoothCurve->dataSourceCurve()->xColumn();
 		}
 
 		if (xDataColumn) {
 			uiGeneralTab.sbMin->setValue(xDataColumn->minimum());
 			uiGeneralTab.sbMax->setValue(xDataColumn->maximum());
 		}
 	} else {
 		uiGeneralTab.lMin->setEnabled(true);
 		uiGeneralTab.sbMin->setEnabled(true);
 		uiGeneralTab.lMax->setEnabled(true);
 		uiGeneralTab.sbMax->setEnabled(true);
 	}
 
 }
 void XYSmoothCurveDock::xRangeMinChanged() {
 	double xMin = uiGeneralTab.sbMin->value();
 
 	m_smoothData.xRange.first() = xMin;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYSmoothCurveDock::xRangeMaxChanged() {
 	double xMax = uiGeneralTab.sbMax->value();
 
 	m_smoothData.xRange.last() = xMax;
 	uiGeneralTab.pbRecalculate->setEnabled(true);
 }
 
 void XYSmoothCurveDock::typeChanged() {
 	nsl_smooth_type type = (nsl_smooth_type)uiGeneralTab.cbType->currentIndex();
 	m_smoothData.type = type;
 
 	const QStandardItemModel* model = qobject_cast<const QStandardItemModel*>(uiGeneralTab.cbMode->model());
 	QStandardItem* pad_interp_item = model->item(nsl_smooth_pad_interp);
 	if (type == nsl_smooth_type_moving_average || type == nsl_smooth_type_moving_average_lagged) {
 		uiGeneralTab.lWeight->show();
 		uiGeneralTab.cbWeight->show();
 		// disable interp pad model for MA and MAL
 		pad_interp_item->setFlags(pad_interp_item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 	} else {
 		uiGeneralTab.lWeight->hide();
 		uiGeneralTab.cbWeight->hide();
 		pad_interp_item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
 	}
 
 	if (type == nsl_smooth_type_moving_average_lagged) {
 		uiGeneralTab.sbPoints->setSingleStep(1);
 		uiGeneralTab.sbPoints->setMinimum(2);
 		uiGeneralTab.lRightValue->hide();
 		uiGeneralTab.sbRightValue->hide();
 	} else {
 		uiGeneralTab.sbPoints->setSingleStep(2);
 		uiGeneralTab.sbPoints->setMinimum(3);
 		if (m_smoothData.mode == nsl_smooth_pad_constant) {
 			uiGeneralTab.lRightValue->show();
 			uiGeneralTab.sbRightValue->show();
 		}
 	}
 
 	if (type == nsl_smooth_type_percentile) {
 		uiGeneralTab.lPercentile->show();
 		uiGeneralTab.sbPercentile->show();
 		// disable interp pad model for MA and MAL
 		pad_interp_item->setFlags(pad_interp_item->flags() & ~(Qt::ItemIsSelectable|Qt::ItemIsEnabled));
 	} else {
 		uiGeneralTab.lPercentile->hide();
 		uiGeneralTab.sbPercentile->hide();
 	}
 
 	if (type == nsl_smooth_type_savitzky_golay) {
 		uiGeneralTab.lOrder->show();
 		uiGeneralTab.sbOrder->show();
 	} else {
 		uiGeneralTab.lOrder->hide();
 		uiGeneralTab.sbOrder->hide();
 	}
 
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::pointsChanged() {
 	m_smoothData.points = (unsigned int)uiGeneralTab.sbPoints->value();
 
 	// set maximum order
 	uiGeneralTab.sbOrder->setMaximum((int)m_smoothData.points - 1);
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::weightChanged() {
 	m_smoothData.weight = (nsl_smooth_weight_type)uiGeneralTab.cbWeight->currentIndex();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::percentileChanged() {
 	m_smoothData.percentile = uiGeneralTab.sbPercentile->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::orderChanged() {
 	m_smoothData.order = (unsigned int)uiGeneralTab.sbOrder->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::modeChanged() {
 	m_smoothData.mode = (nsl_smooth_pad_mode)(uiGeneralTab.cbMode->currentIndex());
 
 	if (m_smoothData.mode == nsl_smooth_pad_constant) {
 		uiGeneralTab.lLeftValue->show();
 		uiGeneralTab.sbLeftValue->show();
 		if (m_smoothData.type == nsl_smooth_type_moving_average_lagged) {
 			uiGeneralTab.lRightValue->hide();
 			uiGeneralTab.sbRightValue->hide();
 		} else {
 			uiGeneralTab.lRightValue->show();
 			uiGeneralTab.sbRightValue->show();
 		}
 	} else {
 		uiGeneralTab.lLeftValue->hide();
 		uiGeneralTab.sbLeftValue->hide();
 		uiGeneralTab.lRightValue->hide();
 		uiGeneralTab.sbRightValue->hide();
 	}
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::valueChanged() {
 	m_smoothData.lvalue = uiGeneralTab.sbLeftValue->value();
 	m_smoothData.rvalue = uiGeneralTab.sbRightValue->value();
 
 	enableRecalculate();
 }
 
 void XYSmoothCurveDock::recalculateClicked() {
 	QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
 	for (auto* curve : m_curvesList)
 		dynamic_cast<XYSmoothCurve*>(curve)->setSmoothData(m_smoothData);
 
 	uiGeneralTab.pbRecalculate->setEnabled(false);
 	emit info(i18n("Smoothing status: %1", m_smoothCurve->smoothResult().status));
 	QApplication::restoreOverrideCursor();
 }
 
 void XYSmoothCurveDock::enableRecalculate() const {
 	if (m_initializing)
 		return;
 
 	//no smoothing possible without the x- and y-data
 	bool hasSourceData = false;
 	if (m_smoothCurve->dataSourceType() == XYAnalysisCurve::DataSourceSpreadsheet) {
 		AbstractAspect* aspectX = static_cast<AbstractAspect*>(cbXDataColumn->currentModelIndex().internalPointer());
 		AbstractAspect* aspectY = static_cast<AbstractAspect*>(cbYDataColumn->currentModelIndex().internalPointer());
 		hasSourceData = (aspectX!=nullptr && aspectY!=nullptr);
 	} else {
 		 hasSourceData = (m_smoothCurve->dataSourceCurve() != nullptr);
 	}
 
 	uiGeneralTab.pbRecalculate->setEnabled(hasSourceData);
 }
 
 /*!
  * show the result and details of the smooth
  */
 void XYSmoothCurveDock::showSmoothResult() {
 	const XYSmoothCurve::SmoothResult& smoothResult = m_smoothCurve->smoothResult();
 	if (!smoothResult.available) {
 		uiGeneralTab.teResult->clear();
 		return;
 	}
 
 	//const XYSmoothCurve::SmoothData& smoothData = m_smoothCurve->smoothData();
 	QString str = i18n("status: %1", smoothResult.status) + "<br>";
 
 	if (!smoothResult.valid) {
 		uiGeneralTab.teResult->setText(str);
 		return; //result is not valid, there was an error which is shown in the status-string, nothing to show more.
 	}
 
 	if (smoothResult.elapsedTime>1000)
 		str += i18n("calculation time: %1 s", QString::number(smoothResult.elapsedTime/1000)) + "<br>";
 	else
 		str += i18n("calculation time: %1 ms", QString::number(smoothResult.elapsedTime)) + "<br>";
 
  	str += "<br><br>";
 
 	uiGeneralTab.teResult->setText(str);
 
 	//enable the "recalculate"-button if the source data was changed since the last smooth
 	uiGeneralTab.pbRecalculate->setEnabled(m_smoothCurve->isSourceDataChangedSinceLastRecalc());
 }
 
 //*************************************************************
 //*********** SLOTs for changes triggered in XYCurve **********
 //*************************************************************
 //General-Tab
 void XYSmoothCurveDock::curveDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_curve != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != uiGeneralTab.leName->text())
 		uiGeneralTab.leName->setText(aspect->name());
 	else if (aspect->comment() != uiGeneralTab.leComment->text())
 		uiGeneralTab.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveDataSourceTypeChanged(XYAnalysisCurve::DataSourceType type) {
 	m_initializing = true;
 	uiGeneralTab.cbDataSourceType->setCurrentIndex(type);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveDataSourceCurveChanged(const XYCurve* curve) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbDataSourceCurve, curve);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveXDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbXDataColumn, column);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveYDataColumnChanged(const AbstractColumn* column) {
 	m_initializing = true;
 	XYCurveDock::setModelIndexFromAspect(cbYDataColumn, column);
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::curveSmoothDataChanged(const XYSmoothCurve::SmoothData& smoothData) {
 	m_initializing = true;
 	m_smoothData = smoothData;
 	uiGeneralTab.cbType->setCurrentIndex(m_smoothData.type);
 
 	this->showSmoothResult();
 	m_initializing = false;
 }
 
 void XYSmoothCurveDock::dataChanged() {
 	this->enableRecalculate();
 }
diff --git a/src/kdefrontend/spreadsheet/DropValuesDialog.cpp b/src/kdefrontend/spreadsheet/DropValuesDialog.cpp
index a98a29069..b0876aeef 100644
--- a/src/kdefrontend/spreadsheet/DropValuesDialog.cpp
+++ b/src/kdefrontend/spreadsheet/DropValuesDialog.cpp
@@ -1,346 +1,346 @@
 /***************************************************************************
     File                 : DropValuesDialog.cpp
     Project              : LabPlot
     Description          : Dialog for droping and masking values in columns
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "DropValuesDialog.h"
 #include "backend/core/column/Column.h"
 #include "backend/lib/macros.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 
 #include <QThreadPool>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <KLocalizedString>
 
 #include <cmath>
 
 /*!
 	\class DropValuesDialog
 	\brief Dialog for generating values from a mathematical function.
 
 	\ingroup kdefrontend
  */
 
 DropValuesDialog::DropValuesDialog(Spreadsheet* s, bool mask, QWidget* parent) : QDialog(parent),
 	m_spreadsheet(s), m_mask(mask) {
 
 	setWindowTitle(i18nc("@title:window", "Drop Values"));
 
 	ui.setupUi(this);
     setAttribute(Qt::WA_DeleteOnClose);
 	ui.cbOperator->addItem(i18n("Equal to"));
 	ui.cbOperator->addItem(i18n("Between (Including End Points)"));
 	ui.cbOperator->addItem(i18n("Between (Excluding End Points)"));
 	ui.cbOperator->addItem(i18n("Greater than"));
 	ui.cbOperator->addItem(i18n("Greater than or Equal to"));
 	ui.cbOperator->addItem(i18n("Lesser than"));
 	ui.cbOperator->addItem(i18n("Lesser than or Equal to"));
 
 	ui.leValue1->setValidator( new QDoubleValidator(ui.leValue1) );
 	ui.leValue2->setValidator( new QDoubleValidator(ui.leValue2) );
 
 	QDialogButtonBox* btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
 	ui.horizontalLayout->addWidget(btnBox);
 	m_okButton = btnBox->button(QDialogButtonBox::Ok);
 
 	connect(btnBox->button(QDialogButtonBox::Cancel), &QPushButton::clicked, this, &DropValuesDialog::close);
 
 	if (m_mask) {
 		m_okButton->setText(i18n("&Mask"));
 		m_okButton->setToolTip(i18n("Mask values in the specified region"));
 		ui.lMode->setText(i18n("Mask values"));
 		setWindowTitle(i18nc("@title:window", "Mask Values"));
 	} else {
 		m_okButton->setText(i18n("&Drop"));
 		m_okButton->setToolTip(i18n("Drop values in the specified region"));
 	}
 
 	connect(ui.cbOperator, static_cast<void (QComboBox::*) (int)>(&QComboBox::currentIndexChanged), this, &DropValuesDialog::operatorChanged );
 	connect(m_okButton, &QPushButton::clicked, this, &DropValuesDialog::okClicked);
 	connect(btnBox, &QDialogButtonBox::accepted, this, &DropValuesDialog::accept);
 	connect(btnBox, &QDialogButtonBox::rejected, this, &DropValuesDialog::reject);
 
 	resize( QSize(400,0).expandedTo(minimumSize()) );
 	operatorChanged(0);
 }
 
 void DropValuesDialog::setColumns(QVector<Column*> columns) {
 	m_columns = columns;
 }
 
 void DropValuesDialog::operatorChanged(int index) const {
 	bool value2 = (index==1) || (index==2);
 	ui.lMin->setVisible(value2);
 	ui.lMax->setVisible(value2);
 	ui.lAnd->setVisible(value2);
 	ui.leValue2->setVisible(value2);
 }
 
 void DropValuesDialog::okClicked() const {
 	if (m_mask)
 		maskValues();
 	else
 		dropValues();
 }
 
 //TODO: m_column->setMasked() is slow, we need direct access to the masked-container -> redesign
 class MaskValuesTask : public QRunnable {
 	public:
 		MaskValuesTask(Column* col, int op, double value1, double value2){
 			m_column = col;
 			m_operator = op;
 			m_value1 = value1;
 			m_value2 = value2;
 		}
 
 		void run() override {
 			m_column->setSuppressDataChangedSignal(true);
 			bool changed = false;
 			QVector<double>* data = static_cast<QVector<double>* >(m_column->data());
 
 			//equal to
 			if (m_operator == 0) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) == m_value1) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//between (including end points)
 			else if (m_operator == 1) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) >= m_value1 && data->at(i) <= m_value2) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//between (excluding end points)
 			else if (m_operator == 2) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) > m_value1 && data->at(i) < m_value2) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//greater than
 			else if (m_operator == 3) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) > m_value1) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//greater than or equal to
 			else if (m_operator == 4) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) >= m_value1) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//lesser than
 			else if (m_operator == 5) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) < m_value1) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			//lesser than or equal to
 			else if (m_operator == 6) {
 				for (int i=0; i<data->size(); ++i) {
 					if (data->at(i) <= m_value1) {
 						m_column->setMasked(i, true);
 						changed = true;
 					}
 				}
 			}
 
 			m_column->setSuppressDataChangedSignal(false);
 			if (changed)
 				m_column->setChanged();
 		}
 
 	private:
 		Column* m_column;
 		int m_operator;
 		double m_value1;
 		double m_value2;
 };
 
 class DropValuesTask : public QRunnable {
 	public:
 		DropValuesTask(Column* col, int op, double value1, double value2){
 			m_column = col;
 			m_operator = op;
 			m_value1 = value1;
 			m_value2 = value2;
 		}
 
 		void run() override {
 			bool changed = false;
 			QVector<double>* data = static_cast<QVector<double>* >(m_column->data());
 			QVector<double> new_data(*data);
 
 			//equal to
 			if (m_operator == 0) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d == m_value1) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//between (including end points)
 			else if (m_operator == 1) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d >= m_value1 && d <= m_value2) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//between (excluding end points)
 			else if (m_operator == 2) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d > m_value1 && d < m_value2) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//greater than
 			else if (m_operator == 3) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d > m_value1) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//greater than or equal to
 			else if (m_operator == 4) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d >= m_value1) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//less than
 			else if (m_operator == 5) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d < m_value1) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			//less than or equal to
 			else if (m_operator == 6) {
-				for (auto d: new_data) {
+				for (auto d : new_data) {
 					if (d <= m_value1) {
 						d = NAN;
 						changed = true;
 					}
 				}
 			}
 
 			if (changed)
 				m_column->replaceValues(0, new_data);
 		}
 
 	private:
 		Column* m_column;
 		int m_operator;
 		double m_value1;
 		double m_value2;
 };
 
 void DropValuesDialog::maskValues() const {
 	Q_ASSERT(m_spreadsheet);
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: mask values", m_spreadsheet->name()));
 
 	const int op = ui.cbOperator->currentIndex();
 	const double value1 = ui.leValue1->text().toDouble();
 	const double value2 = ui.leValue2->text().toDouble();
 
 	for(Column* col: m_columns) {
 		MaskValuesTask* task = new MaskValuesTask(col, op, value1, value2);
 		task->run();
 		//TODO: writing to the undo-stack in Column::setMasked() is not tread-safe -> redesign
 // 		QThreadPool::globalInstance()->start(task);
 	}
 
 	//wait until all columns were processed
 // 	QThreadPool::globalInstance()->waitForDone();
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
 
 void DropValuesDialog::dropValues() const {
 	Q_ASSERT(m_spreadsheet);
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18n("%1: drop values", m_spreadsheet->name()));
 
 	const int op = ui.cbOperator->currentIndex();
 	const double value1 = ui.leValue1->text().toDouble();
 	const double value2 = ui.leValue2->text().toDouble();
 
 	for(Column* col: m_columns) {
 		DropValuesTask* task = new DropValuesTask(col, op, value1, value2);
 		QThreadPool::globalInstance()->start(task);
 	}
 
 	//wait until all columns were processed
 	QThreadPool::globalInstance()->waitForDone();
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
diff --git a/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp b/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
index 03bc44e8b..cb2fd4199 100644
--- a/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
+++ b/src/kdefrontend/spreadsheet/FunctionValuesDialog.cpp
@@ -1,367 +1,367 @@
 /***************************************************************************
     File                 : FunctionValuesDialog.cpp
     Project              : LabPlot
     Description          : Dialog for generating values from a mathematical function
     --------------------------------------------------------------------
     Copyright            : (C) 2014-2015 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "FunctionValuesDialog.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/column/Column.h"
 #include "backend/core/Project.h"
 #include "backend/gsl/ExpressionParser.h"
 #include "backend/lib/macros.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 #include "kdefrontend/widgets/ConstantsWidget.h"
 #include "kdefrontend/widgets/FunctionsWidget.h"
 
 #include <QMenu>
 #include <QWidgetAction>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 #include <cmath>
 
 /*!
 	\class FunctionValuesDialog
 	\brief Dialog for generating values from a mathematical function.
 
 	\ingroup kdefrontend
  */
 
 FunctionValuesDialog::FunctionValuesDialog(Spreadsheet* s, QWidget* parent) : QDialog(parent), m_spreadsheet(s) {
 	Q_ASSERT(s != nullptr);
 	setWindowTitle(i18nc("@title:window", "Function Values"));
 
 	ui.setupUi(this);
 	setAttribute(Qt::WA_DeleteOnClose);
 	ui.tbConstants->setIcon( QIcon::fromTheme("labplot-format-text-symbol") );
 
 	ui.tbConstants->setIcon( QIcon::fromTheme("format-text-symbol") );
 	ui.tbFunctions->setIcon( QIcon::fromTheme("preferences-desktop-font") );
 
 	ui.teEquation->setMaximumHeight(QLineEdit().sizeHint().height()*2);
 	ui.teEquation->setFocus();
 
 	m_topLevelClasses<<"Folder"<<"Workbook"<<"Spreadsheet"<<"FileDataSource"<<"Column";
 	m_selectableClasses<<"Column";
 
 // needed for buggy compiler
 #if __cplusplus < 201103L
 	m_aspectTreeModel = std::auto_ptr<AspectTreeModel>(new AspectTreeModel(m_spreadsheet->project()));
 #else
 	m_aspectTreeModel = std::unique_ptr<AspectTreeModel>(new AspectTreeModel(m_spreadsheet->project()));
 #endif
 	m_aspectTreeModel->setSelectableAspects(m_selectableClasses);
 	m_aspectTreeModel->enableNumericColumnsOnly(true);
 	m_aspectTreeModel->enableNonEmptyNumericColumnsOnly(true);
 
 	ui.bAddVariable->setIcon(QIcon::fromTheme("list-add"));
 	ui.bAddVariable->setToolTip(i18n("Add new variable"));
 
 	QDialogButtonBox* btnBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 
 	ui.verticalLayout->addWidget(btnBox);
 	m_okButton = btnBox->button(QDialogButtonBox::Ok);
 
 	connect(btnBox, &QDialogButtonBox::accepted, this, &FunctionValuesDialog::accept);
 	connect(btnBox, &QDialogButtonBox::rejected, this, &FunctionValuesDialog::reject);
 	m_okButton->setText(i18n("&Generate"));
 	m_okButton->setToolTip(i18n("Generate function values"));
 
 	connect( ui.bAddVariable, SIGNAL(pressed()), this, SLOT(addVariable()) );
 	connect( ui.teEquation, SIGNAL(expressionChanged()), this, SLOT(checkValues()) );
 	connect( ui.tbConstants, SIGNAL(clicked()), this, SLOT(showConstants()) );
 	connect( ui.tbFunctions, SIGNAL(clicked()), this, SLOT(showFunctions()) );
 	connect(m_okButton, &QPushButton::clicked, this, &FunctionValuesDialog::generate);
 
 	//restore saved settings if available
 	KConfigGroup conf(KSharedConfig::openConfig(), "FunctionValuesDialog");
 	if (conf.exists())
 		KWindowConfig::restoreWindowSize(windowHandle(), conf);
 	else
 		resize(QSize(300, 0).expandedTo(minimumSize()));
 }
 
 FunctionValuesDialog::~FunctionValuesDialog() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "FunctionValuesDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void FunctionValuesDialog::setColumns(QVector<Column*> columns) {
 	m_columns = columns;
 	ui.teEquation->setPlainText(m_columns.first()->formula());
 
 	const QStringList& variableNames = m_columns.first()->formulaVariableNames();
 	if (!variableNames.size()) {
 		//no formula was used for this column -> add the first variable "x"
 		addVariable();
 		m_variableNames[0]->setText("x");
 	} else {
 		//formula and variables are available
 		const QStringList& columnPathes = m_columns.first()->formulaVariableColumnPathes();
 
 		//add all available variables and select the corresponding columns
 		const QVector<AbstractAspect*> cols = m_spreadsheet->project()->children("Column", AbstractAspect::Recursive);
 		for (int i = 0; i < variableNames.size(); ++i) {
 			addVariable();
 			m_variableNames[i]->setText(variableNames.at(i));
 
 			for (const auto* aspect : cols) {
 				if (aspect->path() == columnPathes.at(i)) {
 					const AbstractColumn* column = dynamic_cast<const AbstractColumn*>(aspect);
 					if (column)
 						m_variableDataColumns[i]->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(column));
 					else
 						m_variableDataColumns[i]->setCurrentModelIndex(QModelIndex());
 
 					break;
 				}
 			}
 		}
 	}
 }
 
 /*!
 	check the user input and enables/disables the Ok-button depending on the correctness of the input
  */
 void FunctionValuesDialog::checkValues() {
 	//check whether the formula syntax is correct
 	if (!ui.teEquation->isValid()) {
 		m_okButton->setEnabled(false);
 		return;
 	}
 
 	//check whether for the variables where a name was provided also a column was selected.
 	for (int i = 0; i < m_variableDataColumns.size(); ++i) {
 		if (m_variableNames.at(i)->text().simplified().isEmpty())
 			continue;
 
 		TreeViewComboBox* cb = m_variableDataColumns.at(i);
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cb->currentModelIndex().internalPointer());
 		if (!aspect) {
 			m_okButton->setEnabled(false);
 			return;
 		}
 /*		Column* column = dynamic_cast<Column*>(aspect);
 		DEBUG("row count = " << (static_cast<QVector<double>* >(column->data()))->size());
 		if (!column || column->rowCount() < 1) {
 			m_okButton->setEnabled(false);
 			//Warning: x column is empty
 			return;
 		}
 */
 	}
 
 	m_okButton->setEnabled(true);
 }
 
 void FunctionValuesDialog::showConstants() {
 	QMenu menu;
 	ConstantsWidget constants(&menu);
 	connect(&constants, SIGNAL(constantSelected(QString)), this, SLOT(insertConstant(QString)));
 	connect(&constants, SIGNAL(constantSelected(QString)), &menu, SLOT(close()));
 	connect(&constants, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&constants);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width()+ui.tbConstants->width(),-menu.sizeHint().height());
 	menu.exec(ui.tbConstants->mapToGlobal(pos));
 }
 
 void FunctionValuesDialog::showFunctions() {
 	QMenu menu;
 	FunctionsWidget functions(&menu);
 	connect(&functions, SIGNAL(functionSelected(QString)), this, SLOT(insertFunction(QString)));
 	connect(&functions, SIGNAL(functionSelected(QString)), &menu, SLOT(close()));
 	connect(&functions, SIGNAL(canceled()), &menu, SLOT(close()));
 
 	QWidgetAction* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(&functions);
 	menu.addAction(widgetAction);
 
 	QPoint pos(-menu.sizeHint().width()+ui.tbFunctions->width(),-menu.sizeHint().height());
 	menu.exec(ui.tbFunctions->mapToGlobal(pos));
 }
 
 void FunctionValuesDialog::insertFunction(const QString& str) {
 	//TODO: not all functions have only one argument
 	ui.teEquation->insertPlainText(str + "(x)");
 }
 
 void FunctionValuesDialog::insertConstant(const QString& str) {
 	ui.teEquation->insertPlainText(str);
 }
 
 void FunctionValuesDialog::addVariable() {
 	QGridLayout* layout = dynamic_cast<QGridLayout*>(ui.frameVariables->layout());
 	int row = m_variableNames.size();
 
 	//text field for the variable name
 	QLineEdit* le = new QLineEdit();
 	le->setMaximumWidth(30);
 	connect(le, SIGNAL(textChanged(QString)), this, SLOT(variableNameChanged()));
 	layout->addWidget(le, row, 0, 1, 1);
 	m_variableNames << le;
 
 	//label for the "="-sign
 	QLabel* l = new QLabel("=");
 	layout->addWidget(l, row, 1, 1, 1);
 	m_variableLabels << l;
 
 	//combo box for the data column
 	TreeViewComboBox* cb = new TreeViewComboBox();
 	cb->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
 	connect( cb, SIGNAL(currentModelIndexChanged(QModelIndex)), this, SLOT(checkValues()) );
 	layout->addWidget(cb, row, 2, 1, 1);
 	m_variableDataColumns << cb;
 
 	cb->setTopLevelClasses(m_topLevelClasses);
 	cb->setModel(m_aspectTreeModel.get());
 	cb->setCurrentModelIndex(m_aspectTreeModel->modelIndexOfAspect(m_spreadsheet->column(0)));
 
 	//move the add-button to the next row
 	layout->removeWidget(ui.bAddVariable);
 	layout->addWidget(ui.bAddVariable, row+1,3, 1, 1);
 
 	//add delete-button for the just added variable
 	if (row != 0) {
 		QToolButton* b = new QToolButton();
 		b->setIcon(QIcon::fromTheme("list-remove"));
 		b->setToolTip(i18n("Delete variable"));
 		layout->addWidget(b, row, 3, 1, 1);
 		m_variableDeleteButtons<<b;
 		connect(b, SIGNAL(pressed()), this, SLOT(deleteVariable()));
 	}
 
 	ui.lVariable->setText(i18n("Variables:"));
 
 	//TODO: adjust the tab-ordering after new widgets were added
 }
 
 void FunctionValuesDialog::deleteVariable() {
 	QObject* ob = QObject::sender();
 	int index = m_variableDeleteButtons.indexOf(qobject_cast<QToolButton*>(ob)) ;
 
 	delete m_variableNames.takeAt(index+1);
 	delete m_variableLabels.takeAt(index+1);
 	delete m_variableDataColumns.takeAt(index+1);
 	delete m_variableDeleteButtons.takeAt(index);
 
 	variableNameChanged();
 	checkValues();
 
 	//adjust the layout
 	resize( QSize(width(),0).expandedTo(minimumSize()) );
 
 	m_variableNames.size() > 1 ? ui.lVariable->setText(i18n("Variables:")) : ui.lVariable->setText(i18n("Variable:"));
 
 	//TODO: adjust the tab-ordering after some widgets were deleted
 }
 
 void FunctionValuesDialog::variableNameChanged() {
 	QStringList vars;
 	QString text;
-	for (auto varName: m_variableNames) {
+	for (auto* varName : m_variableNames) {
 		QString name = varName->text().simplified();
 		if (!name.isEmpty()) {
 			vars << name;
 
 			if (text.isEmpty()) {
 				text += name;
 			} else {
 				text += ", " + name;
 			}
 		}
 	}
 
 	if (!text.isEmpty())
 		text = "f(" + text + ") = ";
 	else
 		text = "f = ";
 
 	ui.lFunction->setText(text);
 	ui.teEquation->setVariables(vars);
 }
 
 void FunctionValuesDialog::generate() {
 	Q_ASSERT(m_spreadsheet);
 
 	WAIT_CURSOR;
 	m_spreadsheet->beginMacro(i18np("%1: fill column with function values",
 					"%1: fill columns with function values",
 					m_spreadsheet->name(), m_columns.size()));
 
 	//determine variable names and the data vectors of the specified columns
 	QStringList variableNames;
 	QStringList columnPathes;
 	QVector<QVector<double>*> xVectors;
 	QVector<Column*> xColumns;
 	int maxRowCount = m_spreadsheet->rowCount();
 	for (int i = 0; i < m_variableNames.size(); ++i) {
 		variableNames << m_variableNames.at(i)->text().simplified();
 
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(m_variableDataColumns.at(i)->currentModelIndex().internalPointer());
 		Q_ASSERT(aspect);
 		Column* column = dynamic_cast<Column*>(aspect);
 		Q_ASSERT(column);
 		columnPathes << column->path();
 		xColumns << column;
 		xVectors << static_cast<QVector<double>* >(column->data());
 
 		if (column->rowCount() > maxRowCount)
 			maxRowCount = column->rowCount();
 	}
 
 	//resize the spreadsheet if one of the data vectors from other spreadsheet(s) has more elements then the current spreadsheet.
 	if (m_spreadsheet->rowCount() < maxRowCount)
 		m_spreadsheet->setRowCount(maxRowCount);
 
 	//create new vector for storing the calculated values
 	//the vectors with the variable data can be smaller then the result vector. So, not all values in the result vector might get initialized.
 	//->"clean" the result vector first
 	QVector<double> new_data(maxRowCount);
-	for (auto d: new_data)
+	for (auto d : new_data)
 		d = NAN;
 
 	//evaluate the expression for f(x_1, x_2, ...) and write the calculated values into a new vector.
 	ExpressionParser* parser = ExpressionParser::getInstance();
 	const QString& expression = ui.teEquation->toPlainText();
 	parser->evaluateCartesian(expression, variableNames, xVectors, &new_data);
 
 	//set the new values and store the expression, variable names and the used data columns
 	for (auto* col : m_columns) {
 		col->setFormula(expression, variableNames, columnPathes);
 		col->replaceValues(0, new_data);
 	}
 
 	m_spreadsheet->endMacro();
 	RESET_CURSOR;
 }
diff --git a/src/kdefrontend/spreadsheet/PlotDataDialog.cpp b/src/kdefrontend/spreadsheet/PlotDataDialog.cpp
index 5802c9855..6e3d88473 100644
--- a/src/kdefrontend/spreadsheet/PlotDataDialog.cpp
+++ b/src/kdefrontend/spreadsheet/PlotDataDialog.cpp
@@ -1,691 +1,691 @@
 /***************************************************************************
     File                 : PlotDataDialog.cpp
     Project              : LabPlot
     Description          : Dialog for generating plots for the spreadsheet data
     --------------------------------------------------------------------
     Copyright            : (C) 2017 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "PlotDataDialog.h"
 #include "backend/core/AspectTreeModel.h"
 #include "backend/core/Project.h"
 #include "backend/core/column/Column.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/XYAnalysisCurve.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/plots/cartesian/XYDataReductionCurve.h"
 #include "backend/worksheet/plots/cartesian/XYDifferentiationCurve.h"
 #include "backend/worksheet/plots/cartesian/XYIntegrationCurve.h"
 #include "backend/worksheet/plots/cartesian/XYInterpolationCurve.h"
 #include "backend/worksheet/plots/cartesian/XYSmoothCurve.h"
 #include "backend/worksheet/plots/cartesian/XYFitCurve.h"
 #include "backend/worksheet/plots/cartesian/XYFourierFilterCurve.h"
 
 #ifdef HAVE_MQTT
 #include "backend/datasources/MQTTTopic.h"
 #endif
 
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/TextLabel.h"
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
 #include "commonfrontend/widgets/TreeViewComboBox.h"
 
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QTimer>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 #include "ui_plotdatawidget.h"
 
 /*!
 	\class PlotDataDialog
 	\brief Dialog for generating plots for the spreadsheet data.
 
 	\ingroup kdefrontend
  */
 PlotDataDialog::PlotDataDialog(Spreadsheet* s, PlotType type, QWidget* parent) : QDialog(parent),
 	ui(new Ui::PlotDataWidget()),
 	m_spreadsheet(s),
 	m_plotsModel(new AspectTreeModel(m_spreadsheet->project())),
 	m_worksheetsModel(new AspectTreeModel(m_spreadsheet->project())),
 	m_plotType(type),
 	m_analysisAction(Differentiation),
 	m_analysisMode(false) {
 
 	setAttribute(Qt::WA_DeleteOnClose);
 	setWindowTitle(i18nc("@title:window", "Plot Spreadsheet Data"));
 	setWindowIcon(QIcon::fromTheme("office-chart-line"));
 
 	QWidget* mainWidget = new QWidget(this);
 	ui->setupUi(mainWidget);
 
 	QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
 	m_okButton = buttonBox->button(QDialogButtonBox::Ok);
 	m_okButton->setDefault(true);
 	m_okButton->setToolTip(i18n("Plot the selected data"));
 	m_okButton->setText(i18n("&Plot"));
 
 	QVBoxLayout* layout = new QVBoxLayout(this);
 	layout->addWidget(mainWidget);
 	layout->addWidget(buttonBox);
 	setLayout(layout);
 
 	//create combox boxes for the existing plots and worksheets
 	QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(ui->gbPlotPlacement->layout());
 	cbExistingPlots = new TreeViewComboBox(ui->gbPlotPlacement);
 	cbExistingPlots->setMinimumWidth(250);//TODO: use proper sizeHint in TreeViewComboBox
 	gridLayout->addWidget(cbExistingPlots, 0, 1, 1, 1);
 
 	cbExistingWorksheets = new TreeViewComboBox(ui->gbPlotPlacement);
 	cbExistingWorksheets->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
 	gridLayout->addWidget(cbExistingWorksheets, 1, 1, 1, 1);
 
 	QList<const char*> list;
 	list<<"Folder"<<"Worksheet"<<"CartesianPlot";
 	cbExistingPlots->setTopLevelClasses(list);
 	list.clear();
 	list<<"CartesianPlot";
 	m_plotsModel->setSelectableAspects(list);
 	cbExistingPlots->setModel(m_plotsModel);
 
 	//select the first available plot, if available
 	auto plots = m_spreadsheet->project()->children<CartesianPlot>(AbstractAspect::Recursive);
 	if (!plots.isEmpty()) {
-		const auto plot = plots.first();
+		const auto* plot = plots.first();
 		cbExistingPlots->setCurrentModelIndex(m_plotsModel->modelIndexOfAspect(plot));
 	}
 
 	list.clear();
 	list<<"Folder"<<"Worksheet";
 	cbExistingWorksheets->setTopLevelClasses(list);
 	list.clear();
 	list<<"Worksheet";
 	m_worksheetsModel->setSelectableAspects(list);
 	cbExistingWorksheets->setModel(m_worksheetsModel);
 
 	//select the first available worksheet, if available
 	auto worksheets = m_spreadsheet->project()->children<Worksheet>(AbstractAspect::Recursive);
 	if (!worksheets.isEmpty()) {
-		const auto worksheet = worksheets.first();
+		const auto* worksheet = worksheets.first();
 		cbExistingWorksheets->setCurrentModelIndex(m_worksheetsModel->modelIndexOfAspect(worksheet));
 	}
 
 	//hide the check box for creation of original data, only shown if analysis curves are to be created
 	ui->chkCreateDataCurve->setVisible(false);
 
 	//SIGNALs/SLOTs
 	connect(buttonBox, &QDialogButtonBox::accepted, this, [=]() { hide();  plot(); });
 	connect(buttonBox, &QDialogButtonBox::rejected, this, &PlotDataDialog::reject);
 	connect(buttonBox, &QDialogButtonBox::accepted, this, &PlotDataDialog::accept);
 	connect(ui->rbCurvePlacement1, &QRadioButton::toggled, this, &PlotDataDialog::curvePlacementChanged);
 	connect(ui->rbCurvePlacement2, &QRadioButton::toggled, this, &PlotDataDialog::curvePlacementChanged);
 	connect(ui->rbPlotPlacement1, &QRadioButton::toggled, this, &PlotDataDialog::plotPlacementChanged);
 	connect(ui->rbPlotPlacement2, &QRadioButton::toggled, this, &PlotDataDialog::plotPlacementChanged);
 	connect(ui->rbPlotPlacement3, &QRadioButton::toggled, this, &PlotDataDialog::plotPlacementChanged);
 	connect(cbExistingPlots, &TreeViewComboBox::currentModelIndexChanged, this, &PlotDataDialog::checkOkButton);
 	connect(cbExistingWorksheets, &TreeViewComboBox::currentModelIndexChanged, this, &PlotDataDialog::checkOkButton);
 
 	QTimer::singleShot(0, this, &PlotDataDialog::loadSettings);
 }
 
 void PlotDataDialog::loadSettings() {
 	//restore saved settings if available
 	 QApplication::processEvents(QEventLoop::AllEvents, 0);
 	const KConfigGroup conf(KSharedConfig::openConfig(), "PlotDataDialog");
 	if (conf.exists()) {
 		KWindowConfig::restoreWindowSize(windowHandle(), conf);
 
 		int index = conf.readEntry("CurvePlacement", 0);
 		if (index == 2) ui->rbCurvePlacement2->setChecked(true);
 
 		index = conf.readEntry("PlotPlacement", 0);
 		if (index == 2) ui->rbPlotPlacement2->setChecked(true);
 		if (index == 3) ui->rbPlotPlacement3->setChecked(true);
 	} else
 		resize( QSize(0,0).expandedTo(minimumSize()) );
 
 	processColumns();
 	plotPlacementChanged();
 }
 
 PlotDataDialog::~PlotDataDialog() {
 	//save current settings
 	KConfigGroup conf(KSharedConfig::openConfig(), "PlotDataDialog");
 	int index = 0;
 	if (ui->rbCurvePlacement1->isChecked()) index = 1;
 	if (ui->rbCurvePlacement2->isChecked()) index = 2;
 	conf.writeEntry("CurvePlacement", index);
 
 	if (ui->rbPlotPlacement1->isChecked()) index = 1;
 	if (ui->rbPlotPlacement2->isChecked()) index = 2;
 	if (ui->rbPlotPlacement3->isChecked()) index = 3;
 	conf.writeEntry("PlotPlacement", index);
 
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 
 	delete m_plotsModel;
 	delete m_worksheetsModel;
 }
 
 void PlotDataDialog::setAnalysisAction(AnalysisAction action) {
 	m_analysisAction = action;
 	m_analysisMode = true;
 	ui->chkCreateDataCurve->setVisible(true);
 }
 
 void PlotDataDialog::processColumns() {
 	//columns to plot
 	SpreadsheetView* view = reinterpret_cast<SpreadsheetView*>(m_spreadsheet->view());
 	QVector<Column*> selectedColumns = view->selectedColumns(true);
 
 	//use all spreadsheet columns if no columns are selected
 	if (selectedColumns.isEmpty())
 		selectedColumns = m_spreadsheet->children<Column>();
 
 	//skip error and non-plottable columns
 	for (Column* col : selectedColumns) {
 		if ((col->plotDesignation() == AbstractColumn::X || col->plotDesignation() == AbstractColumn::Y
 			|| col->plotDesignation() == AbstractColumn::NoDesignation) && col->isPlottable())
 			m_columns << col;
 	}
 
 	//disable everything if the spreadsheet doesn't have any columns to plot
 	if (m_columns.isEmpty()) {
 		ui->gbCurvePlacement->setEnabled(false);
 		ui->gbPlotPlacement->setEnabled(false);
 		return;
 	}
 
 	//determine the column names
 	//and the name of the first column having "X" as the plot designation (relevant for xy-curves only)
 	QStringList columnNames;
 	QString xColumnName;
 	for(const Column* column : m_columns) {
 		columnNames << column->name();
 		if (m_plotType == PlotXYCurve && xColumnName.isEmpty() && column->plotDesignation() == AbstractColumn::X)
 			xColumnName = column->name();
 	}
 
 	if (m_plotType == PlotXYCurve && xColumnName.isEmpty()) {
 		//no X-column was selected -> look for the first non-selected X-column left to the first selected column
 		const int index = m_spreadsheet->indexOfChild<Column>(selectedColumns.first()) - 1;
 		if (index >= 0) {
 			for (int i = index; i >= 0; --i) {
 				Column* column = m_spreadsheet->column(i);
 				if (column->plotDesignation() == AbstractColumn::X) {
 					xColumnName = column->name();
 					m_columns.prepend(column);
 					columnNames.prepend(xColumnName);
 					break;
 				}
 			}
 		}
 	}
 
 	switch (m_plotType) {
 	case PlotXYCurve:
 		processColumnsForXYCurve(columnNames, xColumnName);
 		break;
 	case PlotHistogram:
 		processColumnsForHistogram(columnNames);
 		break;
 	}
 }
 
 void PlotDataDialog::processColumnsForXYCurve(const QStringList& columnNames, const QString& xColumnName) {
 	m_columnComboBoxes << ui->cbXColumn;
 	m_columnComboBoxes << ui->cbYColumn;
 
 	//ui-widget only has one combobox for the y-data -> add additional comboboxes dynamically if required
 	if (m_columns.size()>2) {
 		QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(ui->scrollAreaYColumns->widget()->layout());
 		for (int i = 2; i < m_columns.size(); ++i) {
 			QLabel* label = new QLabel(i18n("Y-data"));
 			QComboBox* comboBox = new QComboBox();
 			gridLayout->addWidget(label, i+1, 0, 1, 1);
 			gridLayout->addWidget(comboBox, i+1, 2, 1, 1);
 			m_columnComboBoxes << comboBox;
 		}
 	} else {
 		//two columns provided, only one curve is possible -> hide the curve placement options
 		ui->rbCurvePlacement1->setChecked(true);
 		ui->gbCurvePlacement->hide();
 		ui->gbPlotPlacement->setTitle(i18n("Add Curve to"));
 	}
 
 	//show all selected/available column names in the data comboboxes
 	for(QComboBox* const comboBox : m_columnComboBoxes)
 		comboBox->addItems(columnNames);
 
 	if (!xColumnName.isEmpty()) {
 		//show in the X-data combobox the first column having X as the plot designation
 		ui->cbXColumn->setCurrentIndex(ui->cbXColumn->findText(xColumnName));
 
 		//for the remaining columns, show the names in the comboboxes for the Y-data
 		//TODO: handle columns with error-designations
 		int yColumnIndex = 1; //the index of the first Y-data comboBox in m_columnComboBoxes
 		for(const QString& name : columnNames) {
 			if (name != xColumnName) {
 				QComboBox* comboBox = m_columnComboBoxes[yColumnIndex];
 				comboBox->setCurrentIndex(comboBox->findText(name));
 				yColumnIndex++;
 			}
 		}
 	} else {
 		//no column with "x plot designation" is selected, simply show all columns in the order they were selected.
 		//first selected column will serve as the x-column.
 		int yColumnIndex = 0;
 		for(const QString& name : columnNames) {
 			QComboBox* comboBox = m_columnComboBoxes[yColumnIndex];
 			comboBox->setCurrentIndex(comboBox->findText(name));
 			yColumnIndex++;
 		}
 	}
 }
 
 void PlotDataDialog::processColumnsForHistogram(const QStringList& columnNames) {
 	ui->gbData->setTitle(i18n("Histogram Data"));
 	ui->line->hide();
 	ui->chkCreateDataCurve->hide();
 
 	//use the already available cbXColumn combo box
 	ui->lXColumn->setText(i18n("Data"));
 	m_columnComboBoxes << ui->cbXColumn;
 	ui->cbXColumn->addItems(columnNames);
 	ui->cbXColumn->setCurrentIndex(0);
 
 	if (m_columns.size()==1) {
 		//one column provided, only one histogram is possible
 		//-> hide the curve placement options and the scroll areas for further columns
 		ui->rbCurvePlacement1->setChecked(true);
 		ui->gbCurvePlacement->hide();
 		ui->gbPlotPlacement->setTitle(i18n("Add Histogram to"));
 		ui->scrollAreaYColumns->hide();
 	} else {
 		ui->gbCurvePlacement->setTitle(i18n("Histogram Placement"));
 		ui->rbCurvePlacement1->setText(i18n("All histograms in one plot"));
 		ui->rbCurvePlacement2->setText(i18n("One plot per histogram"));
 		ui->gbPlotPlacement->setTitle(i18n("Add Histograms to"));
 
 		//use the already available cbYColumn combo box
 		ui->lYColumn->setText(i18n("Data"));
 		m_columnComboBoxes << ui->cbYColumn;
 		ui->cbYColumn->addItems(columnNames);
 		ui->cbYColumn->setCurrentIndex(1);
 
 		//add a ComboBox for every further column to be plotted
 		QGridLayout* gridLayout = dynamic_cast<QGridLayout*>(ui->scrollAreaYColumns->widget()->layout());
 		for (int i = 2; i < m_columns.size(); ++i) {
 			QLabel* label = new QLabel(i18n("Data"));
 			QComboBox* comboBox = new QComboBox();
 			gridLayout->addWidget(label, i+1, 0, 1, 1);
 			gridLayout->addWidget(comboBox, i+1, 2, 1, 1);
 			comboBox->addItems(columnNames);
 			comboBox->setCurrentIndex(i);
 			m_columnComboBoxes << comboBox;
 		}
 	}
 }
 
 void PlotDataDialog::plot() {
 	DEBUG("PlotDataDialog::plot()");
 	WAIT_CURSOR;
 	if (ui->rbPlotPlacement1->isChecked()) {
 		//add curves to an existing plot
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbExistingPlots->currentModelIndex().internalPointer());
 		CartesianPlot* plot = dynamic_cast<CartesianPlot*>(aspect);
 		plot->beginMacro( i18n("Plot data from %1", m_spreadsheet->name()) );
 		addCurvesToPlot(plot);
 		plot->endMacro();
 	} else if (ui->rbPlotPlacement2->isChecked()) {
 		//add curves to a new plot in an existing worksheet
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbExistingWorksheets->currentModelIndex().internalPointer());
 		Worksheet* worksheet = dynamic_cast<Worksheet*>(aspect);
 		worksheet->beginMacro( i18n("Plot data from %1", m_spreadsheet->name()) );
 
 		if (ui->rbCurvePlacement1->isChecked()) {
 			//all curves in one plot
 			CartesianPlot* plot = new CartesianPlot( i18n("Plot data from %1", m_spreadsheet->name()) );
 			plot->initDefault(CartesianPlot::FourAxes);
 
 			//set the axis titles before we add the plot to the worksheet
 			//set the x-axis names
 			const QString& xColumnName = ui->cbXColumn->currentText();
-			for (auto axis : plot->children<Axis>()) {
+			for (auto* axis : plot->children<Axis>()) {
 				if (axis->orientation() == Axis::AxisHorizontal) {
 					axis->title()->setText(xColumnName);
 					break;
 				}
 			}
 
 			//if we only have one single y-column to plot, we can set the title of the y-axes
 			if (m_columnComboBoxes.size() == 2) {
 				const QString& yColumnName = m_columnComboBoxes[1]->currentText();
-				for (auto axis : plot->children<Axis>()) {
+				for (auto* axis : plot->children<Axis>()) {
 					if (axis->orientation() == Axis::AxisVertical) {
 						axis->title()->setText(yColumnName);
 						break;
 					}
 				}
 			}
 
 			worksheet->addChild(plot);
 			addCurvesToPlot(plot);
 		} else {
 			//one plot per curve
 			addCurvesToPlots(worksheet);
 		}
 		worksheet->endMacro();
 	} else {
 		//add curves to a new plot(s) in a new worksheet
 		AbstractAspect* parent = m_spreadsheet->parentAspect();
 #ifdef HAVE_MQTT
 		MQTTTopic* topic = qobject_cast<MQTTTopic*>(m_spreadsheet);
 		if(topic != nullptr)
 			parent = qobject_cast<AbstractAspect*>(m_spreadsheet->project());
 #endif
 		parent->beginMacro( i18n("Plot data from %1", m_spreadsheet->name()) );
 		Worksheet* worksheet = new Worksheet(i18n("Plot data from %1", m_spreadsheet->name()));
 		parent->addChild(worksheet);
 
 		if (ui->rbCurvePlacement1->isChecked()) {
 			//all curves in one plot
 			CartesianPlot* plot = new CartesianPlot( i18n("Plot data from %1", m_spreadsheet->name()) );
 			plot->initDefault(CartesianPlot::FourAxes);
 
 			//set the axis titles before we add the plot to the worksheet
 			//set the x-axis names
 			const QString& xColumnName = ui->cbXColumn->currentText();
-			for (auto axis : plot->children<Axis>()) {
+			for (auto* axis : plot->children<Axis>()) {
 				if (axis->orientation() == Axis::AxisHorizontal) {
 					axis->title()->setText(xColumnName);
 					break;
 				}
 			}
 
 			//if we only have one single y-column to plot, we can set the title of the y-axes
 			if (m_columnComboBoxes.size() == 2) {
 				const QString& yColumnName = m_columnComboBoxes[1]->currentText();
-				for (auto axis : plot->children<Axis>()) {
+				for (auto* axis : plot->children<Axis>()) {
 					if (axis->orientation() == Axis::AxisVertical) {
 						axis->title()->setText(yColumnName);
 						break;
 					}
 				}
 			}
 
 			worksheet->addChild(plot);
 			addCurvesToPlot(plot);
 		} else {
 			//one plot per curve
 			addCurvesToPlots(worksheet);
 		}
 
 		parent->endMacro();
 	}
 	RESET_CURSOR;
 }
 
 Column* PlotDataDialog::columnFromName(const QString& name) const {
 	for(auto* column : m_columns) {
 		if (column->name() == name)
 			return column;
 	}
 	return nullptr;
 }
 
 /*!
  * * for the selected columns in this dialog, creates a curve in the already existing plot \c plot.
  */
 void PlotDataDialog::addCurvesToPlot(CartesianPlot* plot) const {
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 	switch (m_plotType) {
 	case PlotXYCurve: {
 		Column* xColumn = columnFromName(ui->cbXColumn->currentText());
-		for (auto comboBox: m_columnComboBoxes) {
+		for (auto* comboBox : m_columnComboBoxes) {
 			const QString& name = comboBox->currentText();
 			Column* yColumn = columnFromName(name);
 			addCurve(name, xColumn, yColumn, plot);
 		}
 		break;
 	}
 	case PlotHistogram: {
-		for (auto comboBox: m_columnComboBoxes) {
+		for (auto* comboBox : m_columnComboBoxes) {
 			const QString& name = comboBox->currentText();
 			Column* column = columnFromName(name);
 			addHistogram(name, column, plot);
 		}
 		break;
 	}
 	}
 
 	plot->scaleAuto();
 }
 
 /*!
  * for the selected columns in this dialog, creates a plot and a curve in the already existing worksheet \c worksheet.
  */
 void PlotDataDialog::addCurvesToPlots(Worksheet* worksheet) const {
 	QApplication::processEvents(QEventLoop::AllEvents, 100);
 	worksheet->setSuppressLayoutUpdate(true);
 
 	switch (m_plotType) {
 	case PlotXYCurve: {
 		const QString& xColumnName = ui->cbXColumn->currentText();
 		Column* xColumn = columnFromName(xColumnName);
-		for (auto comboBox: m_columnComboBoxes) {
+		for (auto* comboBox : m_columnComboBoxes) {
 			const QString& name = comboBox->currentText();
 			Column* yColumn = columnFromName(name);
 
 			CartesianPlot* plot = new CartesianPlot(i18n("Plot %1", name));
 			plot->initDefault(CartesianPlot::FourAxes);
 
 			//set the axis names in the new plot
 			bool xSet = false;
 			bool ySet = false;
-			for (auto axis : plot->children<Axis>()) {
+			for (auto* axis : plot->children<Axis>()) {
 				if (axis->orientation() == Axis::AxisHorizontal && !xSet) {
 					axis->title()->setText(xColumnName);
 					xSet = true;
 				} else if (axis->orientation() == Axis::AxisVertical && !ySet) {
 					axis->title()->setText(name);
 					ySet = true;
 				}
 			}
 
 			worksheet->addChild(plot);
 			addCurve(name, xColumn, yColumn, plot);
 			plot->scaleAuto();
 		}
 		break;
 	}
 	case PlotHistogram: {
-		for (auto comboBox: m_columnComboBoxes) {
+		for (auto* comboBox : m_columnComboBoxes) {
 			const QString& name = comboBox->currentText();
 			Column* column = columnFromName(name);
 
 			CartesianPlot* plot = new CartesianPlot(i18n("Plot %1", name));
 			plot->initDefault(CartesianPlot::FourAxes);
 
 			//set the axis names in the new plot
 			bool xSet = false;
-			for (auto axis : plot->children<Axis>()) {
+			for (auto* axis : plot->children<Axis>()) {
 				if (axis->orientation() == Axis::AxisHorizontal && !xSet) {
 					axis->title()->setText(name);
 					xSet = true;
 				}
 			}
 
 			worksheet->addChild(plot);
 			addHistogram(name, column, plot);
 			plot->scaleAuto();
 		}
 	}
 	}
 
 	worksheet->setSuppressLayoutUpdate(false);
 	worksheet->updateLayout();
 }
 
 /*!
  * helper function that does the actual creation of the curve and adding it as child to the \c plot.
  */
 void PlotDataDialog::addCurve(const QString& name, Column* xColumn, Column* yColumn, CartesianPlot* plot) const {
 	DEBUG("PlotDataDialog::addCurve()");
 	if (!m_analysisMode) {
 		XYCurve* curve = new XYCurve(name);
 		curve->suppressRetransform(true);
 		curve->setXColumn(xColumn);
 		curve->setYColumn(yColumn);
 		curve->suppressRetransform(false);
 		plot->addChild(curve);
 	} else {
 		bool createDataCurve = ui->chkCreateDataCurve->isChecked();
 		XYCurve* curve = nullptr;
 		if (createDataCurve) {
 			curve = new XYCurve(name);
 			curve->suppressRetransform(true);
 			curve->setXColumn(xColumn);
 			curve->setYColumn(yColumn);
 			curve->suppressRetransform(false);
 			plot->addChild(curve);
 		}
 
 		XYAnalysisCurve* analysisCurve = nullptr;
 		switch (m_analysisAction) {
 			case DataReduction:
 				analysisCurve = new XYDataReductionCurve(i18n("Reduction of '%1'", name));
 				break;
 			case Differentiation:
 				analysisCurve = new XYDifferentiationCurve(i18n("Derivative of '%1'", name));
 				break;
 			case Integration:
 				analysisCurve = new XYIntegrationCurve(i18n("Integral of '%1'", name));
 				break;
 			case Interpolation:
 				analysisCurve = new XYInterpolationCurve(i18n("Interpolation of '%1'", name));
 				break;
 			case Smoothing:
 				analysisCurve = new XYSmoothCurve(i18n("Smoothing of '%1'", name));
 				break;
 			case FitLinear:
 			case FitPower:
 			case FitExp1:
 			case FitExp2:
 			case FitInvExp:
 			case FitGauss:
 			case FitCauchyLorentz:
 			case FitTan:
 			case FitTanh:
 			case FitErrFunc:
 			case FitCustom:
 				analysisCurve = new XYFitCurve(i18n("Fit to '%1'", name));
 				static_cast<XYFitCurve*>(analysisCurve)->initFitData(m_analysisAction);
 				static_cast<XYFitCurve*>(analysisCurve)->initStartValues(curve);
 				break;
 			case FourierFilter:
 				analysisCurve = new XYFourierFilterCurve(i18n("Fourier Filter of '%1'", name));
 				break;
 		}
 
 		if (analysisCurve != nullptr) {
 			analysisCurve->suppressRetransform(true);
 			analysisCurve->setXDataColumn(xColumn);
 			analysisCurve->setYDataColumn(yColumn);
 			analysisCurve->recalculate();
 			analysisCurve->suppressRetransform(false);
 			plot->addChild(analysisCurve);
 		}
 	}
 }
 
 void PlotDataDialog::addHistogram(const QString& name, Column* column, CartesianPlot* plot) const {
 	Histogram* hist = new Histogram(name);
 	plot->addChild(hist);
 // 	hist->suppressRetransform(true);
 	hist->setDataColumn(column);
 // 	hist->suppressRetransform(false);
 }
 
 //################################################################
 //########################## Slots ###############################
 //################################################################
 void PlotDataDialog::curvePlacementChanged() {
 	if (ui->rbCurvePlacement1->isChecked()) {
 		ui->rbPlotPlacement1->setEnabled(true);
 		ui->rbPlotPlacement2->setText(i18n("new plot in an existing worksheet"));
 		ui->rbPlotPlacement3->setText(i18n("new plot in a new worksheet"));
 	} else {
 		ui->rbPlotPlacement1->setEnabled(false);
 		if (ui->rbPlotPlacement1->isChecked())
 			ui->rbPlotPlacement2->setChecked(true);
 		ui->rbPlotPlacement2->setText(i18n("new plots in an existing worksheet"));
 		ui->rbPlotPlacement3->setText(i18n("new plots in a new worksheet"));
 	}
 }
 
 void PlotDataDialog::plotPlacementChanged() {
 	if (ui->rbPlotPlacement1->isChecked()) {
 		cbExistingPlots->setEnabled(true);
 		cbExistingWorksheets->setEnabled(false);
 	} else if (ui->rbPlotPlacement2->isChecked()) {
 		cbExistingPlots->setEnabled(false);
 		cbExistingWorksheets->setEnabled(true);
 	} else {
 		cbExistingPlots->setEnabled(false);
 		cbExistingWorksheets->setEnabled(false);
 	}
 
 	checkOkButton();
 }
 
 void PlotDataDialog::checkOkButton() {
 	bool enable = false;
 	QString msg;
 	if ( (m_plotType == PlotXYCurve && (ui->cbXColumn->currentIndex() == -1 || ui->cbYColumn->currentIndex() == -1)) ||
 		(m_plotType == PlotHistogram && ui->cbXColumn->currentIndex() == -1) )
 		msg = i18n("No data selected to plot.");
 	else if (ui->rbPlotPlacement1->isChecked()) {
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbExistingPlots->currentModelIndex().internalPointer());
 		enable = (aspect!=nullptr);
 		if (!enable)
 			msg = i18n("An already existing plot has to be selected.");
 	} else if (ui->rbPlotPlacement2->isChecked()) {
 		AbstractAspect* aspect = static_cast<AbstractAspect*>(cbExistingWorksheets->currentModelIndex().internalPointer());
 		enable = (aspect!=nullptr);
 		if (!enable)
 			msg = i18n("An already existing worksheet has to be selected.");
 	} else
 		enable = true;
 
 	m_okButton->setEnabled(enable);
 	if (enable)
 		m_okButton->setToolTip(i18n("Close the dialog and plot the data."));
 	else
 		m_okButton->setToolTip(msg);
 }
diff --git a/src/kdefrontend/spreadsheet/SortDialog.cpp b/src/kdefrontend/spreadsheet/SortDialog.cpp
index 2edd24c41..5dd8deec2 100644
--- a/src/kdefrontend/spreadsheet/SortDialog.cpp
+++ b/src/kdefrontend/spreadsheet/SortDialog.cpp
@@ -1,91 +1,91 @@
 /***************************************************************************
     File                 : SortDialog.h
     Project              : LabPlot
     Description          : Sorting options dialog
     --------------------------------------------------------------------
     Copyright            : (C) 2011 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "SortDialog.h"
 
 #include <QPushButton>
 
 
 /*!
 	\class SortDialog
 	\brief Dialog for sorting the columns in a spreadsheet.
 
 	\ingroup kdefrontend
  */
 
 SortDialog::SortDialog( QWidget* parent ) : QDialog( parent ) {
 
 	setWindowIcon(QIcon::fromTheme("view-sort-ascending"));
 	setWindowTitle(i18nc("@title:window", "Sort Columns"));
 	setSizeGripEnabled(true);
 	setAttribute(Qt::WA_DeleteOnClose);
 
 	ui.setupUi(this);
 
 	ui.buttonBox->button(QDialogButtonBox::Ok)->setText(i18n("Sort"));
 
 	connect(ui.buttonBox, &QDialogButtonBox::accepted, this, &SortDialog::sortColumns);
 	connect(ui.buttonBox, &QDialogButtonBox::rejected, this, &SortDialog::reject);
 	connect(ui.buttonBox, &QDialogButtonBox::accepted, this, &SortDialog::accept);
 
 	connect(ui.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(changeType(int)));
 
 	resize(minimumSize());
 }
 
 void SortDialog::sortColumns() {
 	Column* leading;
 	if (ui.cbType->currentIndex() == Together)
 		leading = m_columns.at(ui.cbColumns->currentIndex());
 	else
 		leading = nullptr;
 
 	emit sort(leading, m_columns, ui.cbOrdering->currentIndex() == Ascending);
 }
 
 void SortDialog::setColumns(QVector<Column*> columns) {
 	m_columns = columns;
 
-	for (auto col: m_columns)
+	for (auto* col : m_columns)
 		ui.cbColumns->addItem(col->name());
 
 	ui.cbColumns->setCurrentIndex(0);
 
 	if (m_columns.size() == 1) {
 		ui.lType->hide();
 		ui.cbType->hide();
 		ui.lColumns->hide();
 		ui.cbColumns->hide();
 	}
 }
 
 void SortDialog::changeType(int Type) {
 	if (Type == Together)
 		ui.cbColumns->setEnabled(true);
 	else
 		ui.cbColumns->setEnabled(false);
 }
diff --git a/src/kdefrontend/spreadsheet/StatisticsDialog.cpp b/src/kdefrontend/spreadsheet/StatisticsDialog.cpp
index b544d205d..424d550a8 100644
--- a/src/kdefrontend/spreadsheet/StatisticsDialog.cpp
+++ b/src/kdefrontend/spreadsheet/StatisticsDialog.cpp
@@ -1,239 +1,239 @@
 /***************************************************************************
     File                 : StatisticsDialog.cpp
     Project              : LabPlot
     Description          : Dialog showing statistics for column values
     --------------------------------------------------------------------
     Copyright            : (C) 2016-2017 by Fabian Kristof (fkristofszabolcs@gmail.com))
     Copyright            : (C) 2016-2017 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  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 "StatisticsDialog.h"
 #include "backend/core/column/Column.h"
 
 #include <QTextEdit>
 #include <QTimer>
 #include <QTabWidget>
 #include <KLocalizedString>
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 #include <KWindowConfig>
 #include <QPushButton>
 #include <cmath>
 #include <KSharedConfig>
 
 StatisticsDialog::StatisticsDialog(const QString& title, QWidget* parent) :
 	QDialog(parent) {
 
 	m_twStatistics = new QTabWidget;
 
 	QDialogButtonBox* btnBox = new QDialogButtonBox(QDialogButtonBox::Ok);
 
 	QPushButton* btnOk = btnBox->button(QDialogButtonBox::Ok);
 	btnOk->setFocus();
 
 	connect(btnOk, &QPushButton::clicked, this, &StatisticsDialog::close);
 	connect(btnBox, &QDialogButtonBox::accepted, this, &StatisticsDialog::accept);
 
 	QVBoxLayout* layout = new QVBoxLayout;
 	layout->addWidget(m_twStatistics);
 	layout->addWidget(btnBox);
 
 	setLayout(layout);
 
 	setWindowTitle(title);
 	setAttribute(Qt::WA_DeleteOnClose);
 
 	const QString htmlColor = (palette().color(QPalette::Base).lightness() < 128) ? QLatin1String("#5f5f5f") : QLatin1String("#D1D1D1");
 
 	m_htmlText = QString("<table border=0 width=100%>"
 	                     "<tr>"
 	                     "<td colspan=2 align=center bgcolor=" + htmlColor + "><b><big>"
 	                     + i18n("Location measures")+
 	                     "</big><b></td>"
 	                     "</tr>"
 	                     "<tr></tr>"
 	                     "<tr>"
 	                     "<td width=70%><b>"
 	                     + i18n("Minimum")+
 	                     "<b></td>"
 	                     "<td>%1</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Maximum")+
 	                     "<b></td>"
 	                     "<td>%2</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Arithmetic mean")+
 	                     "<b></td>"
 	                     "<td>%3</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Geometric mean")+
 	                     "<b></td>"
 	                     "<td>%4</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Harmonic mean")+
 	                     "<b></td>"
 	                     "<td>%5</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Contraharmonic mean")+
 	                     "<b></td>"
 	                     "<td>%6</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Median")+
 	                     "<b></td>"
 	                     "<td>%7</td>"
 	                     "</tr>"
 	                     "<tr></tr>"
 	                     "<tr>"
 	                     "<td colspan=2 align=center bgcolor=" + htmlColor + "><b><big>"
 	                     + i18n("Dispersion measures")+
 	                     "</big></b></td>"
 	                     "</tr>"
 	                     "<tr></tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Variance")+
 	                     "<b></td>"
 	                     "<td>%8</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Standard deviation")+
 	                     "<b></td>"
 	                     "<td>%9</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Mean absolute deviation around mean")+
 	                     "<b></td>"
 	                     "<td>%10</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Mean absolute deviation around median")+
 	                     "<b></td>"
 	                     "<td>%11</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Median absolute deviation")+
 	                     "<b></td>"
 	                     "<td>%12</td>"
 	                     "</tr>"
 	                     "<tr></tr>"
 	                     "<tr>"
 	                     "<td colspan=2 align=center bgcolor=" + htmlColor + "><b><big>"
 	                     + i18n("Shape measures")+
 	                     "</big></b></td>"
 	                     "</tr>"
 	                     "<tr></tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Skewness")+
 	                     "<b></td>"
 	                     "<td>%13</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Kurtosis")+
 	                     "<b></td>"
 	                     "<td>%14</td>"
 	                     "</tr>"
 	                     "<tr>"
 	                     "<td><b>"
 	                     + i18n("Entropy")+
 	                     "<b></td>"
 	                     "<td>%15</td>"
 	                     "</tr>"
 	                     "</table>");
 
 	connect(m_twStatistics, &QTabWidget::currentChanged, this, &StatisticsDialog::currentTabChanged);
 	QTimer::singleShot(0, this, &StatisticsDialog::loadSettings);
 }
 
 void StatisticsDialog::loadSettings() {
 	//restore saved settings if available
 	QApplication::processEvents(QEventLoop::AllEvents, 0);
 	KConfigGroup conf(KSharedConfig::openConfig(), "StatisticsDialog");
 	if (conf.exists())
 		KWindowConfig::restoreWindowSize(windowHandle(), conf);
 	else
 		resize(QSize(490, 520));
 }
 
 StatisticsDialog::~StatisticsDialog() {
 	KConfigGroup conf(KSharedConfig::openConfig(), "StatisticsDialog");
 	KWindowConfig::saveWindowSize(windowHandle(), conf);
 }
 
 void StatisticsDialog::setColumns(const QVector<Column*>& columns) {
 	if (!columns.size())
 		return;
 
 	m_columns = columns;
 
-	for (auto col: m_columns) {
+	for (auto* col : m_columns) {
 		QTextEdit* textEdit = new QTextEdit;
 		textEdit->setReadOnly(true);
 		m_twStatistics->addTab(textEdit, col->name());
 	}
 	currentTabChanged(0);
 }
 
 const QString StatisticsDialog::isNanValue(const double value) {
 	return (std::isnan(value) ? QLatin1String("-") : QString::number(value,'g', 10));
 }
 
 void StatisticsDialog::currentTabChanged(int index) {
 	WAIT_CURSOR;
 	const Column::ColumnStatistics& statistics = m_columns[index]->statistics();
 	RESET_CURSOR;
 
 	QTextEdit* const textEdit = static_cast<QTextEdit*>(m_twStatistics->currentWidget());
 	textEdit->setHtml(m_htmlText.arg(isNanValue(statistics.minimum == INFINITY ? NAN : statistics.minimum),
 	                                 isNanValue(statistics.maximum == -INFINITY ? NAN : statistics.maximum),
 	                                 isNanValue(statistics.arithmeticMean),
 	                                 isNanValue(statistics.geometricMean),
 	                                 isNanValue(statistics.harmonicMean),
 	                                 isNanValue(statistics.contraharmonicMean),
 	                                 isNanValue(statistics.median),
 	                                 isNanValue(statistics.variance),
 	                                 isNanValue(statistics.standardDeviation)).
 	                  arg(isNanValue(statistics.meanDeviation),
 	                      isNanValue(statistics.meanDeviationAroundMedian),
 	                      isNanValue(statistics.medianDeviation),
 	                      isNanValue(statistics.skewness),
 	                      isNanValue(statistics.kurtosis),
 	                      isNanValue(statistics.entropy)));
 }