diff --git a/src/backend/worksheet/Worksheet.cpp b/src/backend/worksheet/Worksheet.cpp
index 60bef9b89..bbef70fc1 100644
--- a/src/backend/worksheet/Worksheet.cpp
+++ b/src/backend/worksheet/Worksheet.cpp
@@ -1,1605 +1,1604 @@
 /***************************************************************************
     File                 : Worksheet.cpp
     Project              : LabPlot
     Description          : Worksheet
     --------------------------------------------------------------------
     Copyright            : (C) 2009 Tilman Benkert (thzs@gmx.net)
     Copyright            : (C) 2011-2019 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 "Worksheet.h"
 #include "WorksheetPrivate.h"
 #include "WorksheetElement.h"
 #include "commonfrontend/worksheet/WorksheetView.h"
 #include "backend/core/Project.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/worksheet/TreeModel.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "kdefrontend/worksheet/ExportWorksheetDialog.h"
 #include "kdefrontend/ThemeHandler.h"
 
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QDir>
 #include <QGraphicsItem>
 #include <QIcon>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <cmath>
 
 /**
  * \class Worksheet
  * \brief Top-level container for worksheet elements like plot, labels, etc.
  *
  * The worksheet is, besides the data containers \c Spreadsheet and \c Matrix, another central part of the application
  * and provides an area for showing and grouping together different kinds of worksheet objects - plots, labels &etc;
  *
  * * \ingroup worksheet
  */
 Worksheet::Worksheet(const QString& name, bool loading) : AbstractPart(name, AspectType::Worksheet), d(new WorksheetPrivate(this)) {
 	connect(this, &Worksheet::aspectAdded, this, &Worksheet::handleAspectAdded);
 	connect(this, &Worksheet::aspectAboutToBeRemoved, this, &Worksheet::handleAspectAboutToBeRemoved);
 	connect(this, &Worksheet::aspectRemoved, this, &Worksheet::handleAspectRemoved);
 
 	if (!loading)
 		init();
 }
 
 Worksheet::~Worksheet() {
 	delete d;
 }
 
 void Worksheet::init() {
 	KConfig config;
 	KConfigGroup group = config.group("Worksheet");
 
 	//size
 	d->scaleContent = group.readEntry("ScaleContent", false);
 	d->useViewSize = group.readEntry("UseViewSize", false);
 	d->pageRect.setX(0);
 	d->pageRect.setY(0);
 	d->pageRect.setWidth(group.readEntry("Width", 1500));
 	d->pageRect.setHeight(group.readEntry("Height", 1500));
 	d->m_scene->setSceneRect(d->pageRect);
 
 	//background
 	d->backgroundType = (PlotArea::BackgroundType) group.readEntry("BackgroundType", (int) PlotArea::Color);
 	d->backgroundColorStyle = (PlotArea::BackgroundColorStyle) group.readEntry("BackgroundColorStyle", (int) PlotArea::SingleColor);
 	d->backgroundImageStyle = (PlotArea::BackgroundImageStyle) group.readEntry("BackgroundImageStyle", (int) PlotArea::Scaled);
 	d->backgroundBrushStyle = (Qt::BrushStyle) group.readEntry("BackgroundBrushStyle", (int) Qt::SolidPattern);
 	d->backgroundFileName = group.readEntry("BackgroundFileName", QString());
 	d->backgroundFirstColor = group.readEntry("BackgroundFirstColor", QColor(Qt::white));
 	d->backgroundSecondColor = group.readEntry("BackgroundSecondColor", QColor(Qt::black));
 	d->backgroundOpacity = group.readEntry("BackgroundOpacity", 1.0);
 
 	//layout
 	d->layout = (Worksheet::Layout) group.readEntry("Layout", (int) Worksheet::VerticalLayout);
 	d->layoutTopMargin =  group.readEntry("LayoutTopMargin", convertToSceneUnits(1, Centimeter));
 	d->layoutBottomMargin = group.readEntry("LayoutBottomMargin", convertToSceneUnits(1, Centimeter));
 	d->layoutLeftMargin = group.readEntry("LayoutLeftMargin", convertToSceneUnits(1, Centimeter));
 	d->layoutRightMargin = group.readEntry("LayoutRightMargin", convertToSceneUnits(1, Centimeter));
 	d->layoutVerticalSpacing = group.readEntry("LayoutVerticalSpacing", convertToSceneUnits(1, Centimeter));
 	d->layoutHorizontalSpacing = group.readEntry("LayoutHorizontalSpacing", convertToSceneUnits(1, Centimeter));
 	d->layoutRowCount = group.readEntry("LayoutRowCount", 2);
 	d->layoutColumnCount = group.readEntry("LayoutColumnCount", 2);
 
 	//default theme
 	KConfigGroup settings = KSharedConfig::openConfig()->group(QLatin1String("Settings_Worksheet"));
 	d->theme = settings.readEntry(QStringLiteral("Theme"), QString());
 	if (!d->theme.isEmpty())
 		loadTheme(d->theme);
 }
 
 /*!
 	converts from \c unit to the scene units. At the moment, 1 scene unit corresponds to 1/10 mm.
  */
 float Worksheet::convertToSceneUnits(const float value, const Worksheet::Unit unit) {
 	switch (unit) {
 	case Worksheet::Millimeter:
 		return value*10.0;
 	case Worksheet::Centimeter:
 		return value*100.0;
 	case Worksheet::Inch:
 		return value*25.4*10.;
 	case Worksheet::Point:
 		return value*25.4/72.*10.;
 	}
 
 	return 0;
 }
 
 /*!
 	converts from the scene units to \c unit . At the moment, 1 scene unit corresponds to 1/10 mm.
  */
 float Worksheet::convertFromSceneUnits(const float value, const Worksheet::Unit unit) {
 	switch (unit) {
 	case Worksheet::Millimeter:
 		return value/10.0;
 	case Worksheet::Centimeter:
 		return value/100.0;
 	case Worksheet::Inch:
 		return value/25.4/10.;
 	case Worksheet::Point:
 		return value/25.4/10.*72.;
 	}
 
 	return 0;
 }
 
 QIcon Worksheet::icon() const {
 	return QIcon::fromTheme("labplot-worksheet");
 }
 
 /**
  * Return a new context menu. The caller takes ownership of the menu.
  */
 QMenu* Worksheet::createContextMenu() {
 	QMenu* menu = AbstractPart::createContextMenu();
 	Q_ASSERT(menu);
 	emit requestProjectContextMenu(menu);
 	return menu;
 }
 
 //! Construct 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* Worksheet::view() const {
 	if (!m_partView) {
 		m_view = new WorksheetView(const_cast<Worksheet*>(this));
 		m_partView = m_view;
 		connect(m_view, &WorksheetView::statusInfo, this, &Worksheet::statusInfo);
 	}
 	return m_partView;
 }
 
 /*!
  * returns the list of all parent aspects (folders and sub-folders)
  * together with all the data containers required to plot the data in the worksheet
  */
 QVector<AbstractAspect*> Worksheet::dependsOn() const {
 	//add all parent aspects (folders and sub-folders)
 	QVector<AbstractAspect*> aspects = AbstractAspect::dependsOn();
 
 	//traverse all plots and add all data containers they depend on
 	for (const auto* plot : children<AbstractPlot>())
 		aspects << plot->dependsOn();
 
 	return aspects;
 }
 
 bool Worksheet::exportView() const {
 	auto* dlg = new ExportWorksheetDialog(m_view);
 	dlg->setFileName(name());
 	bool ret;
 	if ( (ret = (dlg->exec() == QDialog::Accepted)) ) {
 		QString path = dlg->path();
 		const WorksheetView::ExportFormat format = dlg->exportFormat();
 		const WorksheetView::ExportArea area = dlg->exportArea();
 		const bool background = dlg->exportBackground();
 		const int resolution = dlg->exportResolution();
 
 		WAIT_CURSOR;
 		m_view->exportToFile(path, format, area, background, resolution);
 		RESET_CURSOR;
 	}
 	delete dlg;
 	return ret;
 }
 
 bool Worksheet::printView() {
 	QPrinter printer;
 	auto* dlg = new QPrintDialog(&printer, m_view);
 	dlg->setWindowTitle(i18nc("@title:window", "Print Worksheet"));
 	bool ret;
 	if ( (ret = (dlg->exec() == QDialog::Accepted)) )
 		m_view->print(&printer);
 
 	delete dlg;
 	return ret;
 }
 
 bool Worksheet::printPreview() const {
 	auto* dlg = new QPrintPreviewDialog(m_view);
 	connect(dlg, &QPrintPreviewDialog::paintRequested, m_view, &WorksheetView::print);
 	return dlg->exec();
 }
 
 void Worksheet::handleAspectAdded(const AbstractAspect* aspect) {
 	const auto* addedElement = qobject_cast<const WorksheetElement*>(aspect);
 	if (!addedElement)
 		return;
 
 	if (aspect->parentAspect() != this)
 		return;
 
 	//add the GraphicsItem of the added child to the scene
 	QGraphicsItem* item = addedElement->graphicsItem();
 	d->m_scene->addItem(item);
 
 	const CartesianPlot* plot = dynamic_cast<const CartesianPlot*>(aspect);
 	if(plot){
 		connect(plot, &CartesianPlot::mouseMoveCursorModeSignal, this, &Worksheet::cartesianPlotmouseMoveCursorMode);
 		connect(plot, &CartesianPlot::mouseMoveZoomSelectionModeSignal, this, &Worksheet::cartesianPlotmouseMoveZoomSelectionMode);
 		connect(plot, &CartesianPlot::mousePressCursorModeSignal, this, &Worksheet::cartesianPlotmousePressCursorMode);
 		connect(plot, &CartesianPlot::mousePressZoomSelectionModeSignal, this, &Worksheet::cartesianPlotmousePressZoomSelectionMode);
 		connect(plot, &CartesianPlot::mouseReleaseZoomSelectionModeSignal, this, &Worksheet::cartesianPlotmouseReleaseZoomSelectionMode);
 		connect(plot, &CartesianPlot::mouseHoverZoomSelectionModeSignal, this, &Worksheet::cartesianPlotmouseHoverZoomSelectionMode);
-        connect(plot, &CartesianPlot::curveRemoved, this, &Worksheet::curveRemoved);
-        connect(plot, &CartesianPlot::curveAdded, this, &Worksheet::curveAdded);
+		connect(plot, &CartesianPlot::curveRemoved, this, &Worksheet::curveRemoved);
+		connect(plot, &CartesianPlot::curveAdded, this, &Worksheet::curveAdded);
 		connect(plot, &CartesianPlot::visibleChanged, this, &Worksheet::updateCompleteCursorTreeModel);
 		connect(plot, &CartesianPlot::curveVisibilityChangedSignal, this, &Worksheet::updateCompleteCursorTreeModel);
-        connect(plot, &CartesianPlot::curveDataChanged, this, &Worksheet::curveDataChanged);
-        connect(plot, &CartesianPlot::curveDataChanged, this, &Worksheet::curveDataChanged);
-		connect(plot, QOverload<QPen, QString>::of(&CartesianPlot::curveLinePenChanged), this, &Worksheet::updateCurveBackground);
+		connect(plot, &CartesianPlot::curveDataChanged, this, &Worksheet::curveDataChanged);
+		connect(plot, static_cast<void (CartesianPlot::*)(QPen, QString)>(&CartesianPlot::curveLinePenChanged), this, &Worksheet::updateCurveBackground);
 		connect(plot, &CartesianPlot::mouseModeChanged, this, &Worksheet::cartesianPlotmouseModeChanged);
 		auto* p = const_cast<CartesianPlot*>(plot);
 		p->setLocked(d->plotsLocked);
 
 		cursorModelPlotAdded(p->name());
 	}
 	qreal zVal = 0;
 	for (auto* child : children<WorksheetElement>(IncludeHidden))
 		child->graphicsItem()->setZValue(zVal++);
 
 	//if a theme was selected in the worksheet, apply this theme for newly added children
 	if (!d->theme.isEmpty() && !isLoading()) {
 		KConfig config(ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig);
 		const_cast<WorksheetElement*>(addedElement)->loadThemeConfig(config);
 	}
 
 	//recalculated the layout
 	if (!isLoading()) {
 		if (d->layout != Worksheet::NoLayout)
 			d->updateLayout(false);
 	}
 }
 
 void Worksheet::handleAspectAboutToBeRemoved(const AbstractAspect* aspect) {
 	const auto* removedElement = qobject_cast<const WorksheetElement*>(aspect);
 	if (removedElement) {
 		QGraphicsItem* item = removedElement->graphicsItem();
 		d->m_scene->removeItem(item);
 	}
 }
 
 void Worksheet::handleAspectRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child) {
 	Q_UNUSED(parent);
 	Q_UNUSED(before);
 
 	if (d->layout != Worksheet::NoLayout)
 		d->updateLayout(false);
 	auto* plot = dynamic_cast<const CartesianPlot*>(child);
 	if (plot)
 		cursorModelPlotRemoved(plot->name());
 
 }
 
 QGraphicsScene* Worksheet::scene() const {
 	return d->m_scene;
 }
 
 QRectF Worksheet::pageRect() const {
 	return d->m_scene->sceneRect();
 }
 
 /*!
 	this slot is called when a worksheet element is selected in the project explorer.
 	emits \c itemSelected() which forwards this event to the \c WorksheetView
 	in order to select the corresponding \c QGraphicsItem.
  */
 void Worksheet::childSelected(const AbstractAspect* aspect) {
 	auto* element = qobject_cast<WorksheetElement*>(const_cast<AbstractAspect*>(aspect));
 	if (element)
 		emit itemSelected(element->graphicsItem());
 }
 
 /*!
 	this slot is called when a worksheet element is deselected in the project explorer.
 	emits \c itemDeselected() which forwards this event to \c WorksheetView
 	in order to deselect the corresponding \c QGraphicsItem.
  */
 void Worksheet::childDeselected(const AbstractAspect* aspect) {
 	auto* element = qobject_cast<WorksheetElement*>(const_cast<AbstractAspect*>(aspect));
 	if (element)
 		emit itemDeselected(element->graphicsItem());
 }
 
 /*!
  *  Emits the signal to select or to deselect the aspect corresponding to \c QGraphicsItem \c item 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 WorksheetView upon selection changes.
  */
 void Worksheet::setItemSelectedInView(const QGraphicsItem* item, const bool b) {
 	//determine the corresponding aspect
 	const AbstractAspect* aspect(nullptr);
 	for (const auto* child : children<WorksheetElement>(IncludeHidden) ) {
 		aspect = this->aspectFromGraphicsItem(child, item);
 		if (aspect)
 			break;
 	}
 
 	if (!aspect)
 		return;
 
 	//forward selection/deselection to AbstractTreeModel
 	if (b)
 		emit childAspectSelectedInView(aspect);
 	else
 		emit childAspectDeselectedInView(aspect);
 }
 
 /*!
  * helper function:  checks whether \c aspect or one of its children has the \c GraphicsItem \c item
  * Returns a pointer to \c WorksheetElement having this item.
  */
 WorksheetElement* Worksheet::aspectFromGraphicsItem(const WorksheetElement* aspect, const QGraphicsItem* item) const {
 	if ( aspect->graphicsItem() == item )
 		return const_cast<WorksheetElement*>(aspect);
 	else {
 		for (const auto* child : aspect->children<WorksheetElement>(AbstractAspect::IncludeHidden) ) {
 			WorksheetElement* a = this->aspectFromGraphicsItem(child, item);
 			if (a)
 				return a;
 		}
 		return nullptr;
 	}
 }
 
 /*!
 	Selects or deselects the worksheet in the project explorer.
 	This function is called in \c WorksheetView.
 	The worksheet gets deselected if there are selected items in the view,
 	and selected if there are no selected items in the view.
 */
 void Worksheet::setSelectedInView(const bool b) {
 	if (b)
 		emit childAspectSelectedInView(this);
 	else
 		emit childAspectDeselectedInView(this);
 }
 
 void Worksheet::deleteAspectFromGraphicsItem(const QGraphicsItem* item) {
 	Q_ASSERT(item);
 	//determine the corresponding aspect
 	AbstractAspect* aspect(nullptr);
 	for (const auto* child : children<WorksheetElement>(IncludeHidden) ) {
 		aspect = this->aspectFromGraphicsItem(child, item);
 		if (aspect)
 			break;
 	}
 
 	if (!aspect)
 		return;
 
 	if (aspect->parentAspect())
 		aspect->parentAspect()->removeChild(aspect);
 	else
 		this->removeChild(aspect);
 }
 
 void Worksheet::setIsClosing() {
 	if (m_view)
 		m_view->setIsClosing();
 }
 
 /*!
  * \brief Worksheet::getPlotCount
  * \return number of CartesianPlot's in the Worksheet
  */
 int Worksheet::getPlotCount(){
 	return children<CartesianPlot>().length();
 }
 
 /*!
  * \brief Worksheet::getPlot
  * \param index Number of plot which shoud be returned
  * \return Pointer to the CartesianPlot which was searched with index
  */
 WorksheetElement *Worksheet::getPlot(int index){
 	QVector<CartesianPlot*> cartesianPlots = children<CartesianPlot>();
 	if(cartesianPlots.length()-1 >= index)
 		return cartesianPlots[index];
 	return nullptr;
 }
 
 TreeModel* Worksheet::cursorModel() {
     return d->cursorData;
 }
 
 void Worksheet::update() {
 	emit requestUpdate();
 }
 
 void Worksheet::setSuppressLayoutUpdate(bool value) {
 	d->suppressLayoutUpdate = value;
 }
 
 void Worksheet::updateLayout() {
 	d->updateLayout();
 }
 
 Worksheet::CartesianPlotActionMode Worksheet::cartesianPlotActionMode() {
 	return d->cartesianPlotActionMode;
 }
 
 Worksheet::CartesianPlotActionMode Worksheet::cartesianPlotCursorMode() {
 	return d->cartesianPlotCursorMode;
 }
 
 bool Worksheet::plotsLocked() {
 	return d->plotsLocked;
 }
 
 void Worksheet::setCartesianPlotActionMode(Worksheet::CartesianPlotActionMode mode) {
 	if (d->cartesianPlotActionMode == mode)
 		return;
 
 	d->cartesianPlotActionMode = mode;
 	project()->setChanged(true);
 }
 
 void Worksheet::setCartesianPlotCursorMode(Worksheet::CartesianPlotActionMode mode) {
 	if (d->cartesianPlotCursorMode == mode)
 		return;
 
 	d->cartesianPlotCursorMode = mode;
 
 	if (mode == Worksheet::CartesianPlotActionMode::ApplyActionToAll) {
 		d->suppressCursorPosChanged = true;
 		QVector<CartesianPlot*> plots = children<CartesianPlot>();
 		QPointF logicPos;
 		if (!plots.isEmpty()) {
 			for (int i = 0; i < 2; i++) {
 				logicPos = QPointF(plots[0]->cursorPos(i), 0); // y value does not matter
 				cartesianPlotmousePressCursorMode(i, logicPos);
 			}
 		}
 		d->suppressCursorPosChanged = false;
 	}
 	updateCompleteCursorTreeModel();
 	project()->setChanged(true);
 }
 
 void Worksheet::setPlotsLocked(bool lock) {
 	if (d->plotsLocked == lock)
 		return;
 
 	d->plotsLocked = lock;
 
 	for (auto* plot: children<CartesianPlot>())
 		plot->setLocked(lock);
 
 	project()->setChanged(true);
 }
 
 void Worksheet::registerShortcuts() {
 	m_view->registerShortcuts();
 }
 
 void Worksheet::unregisterShortcuts() {
 	m_view->unregisterShortcuts();
 }
 
 /* =============================== getter methods for general options ==================================== */
 BASIC_D_READER_IMPL(Worksheet, bool, scaleContent, scaleContent)
 BASIC_D_READER_IMPL(Worksheet, bool, useViewSize, useViewSize)
 
 /* =============================== getter methods for background options ================================= */
 BASIC_D_READER_IMPL(Worksheet, PlotArea::BackgroundType, backgroundType, backgroundType)
 BASIC_D_READER_IMPL(Worksheet, PlotArea::BackgroundColorStyle, backgroundColorStyle, backgroundColorStyle)
 BASIC_D_READER_IMPL(Worksheet, PlotArea::BackgroundImageStyle, backgroundImageStyle, backgroundImageStyle)
 BASIC_D_READER_IMPL(Worksheet, Qt::BrushStyle, backgroundBrushStyle, backgroundBrushStyle)
 CLASS_D_READER_IMPL(Worksheet, QColor, backgroundFirstColor, backgroundFirstColor)
 CLASS_D_READER_IMPL(Worksheet, QColor, backgroundSecondColor, backgroundSecondColor)
 CLASS_D_READER_IMPL(Worksheet, QString, backgroundFileName, backgroundFileName)
 BASIC_D_READER_IMPL(Worksheet, float, backgroundOpacity, backgroundOpacity)
 
 /* =============================== getter methods for layout options ====================================== */
 BASIC_D_READER_IMPL(Worksheet, Worksheet::Layout, layout, layout)
 BASIC_D_READER_IMPL(Worksheet, float, layoutTopMargin, layoutTopMargin)
 BASIC_D_READER_IMPL(Worksheet, float, layoutBottomMargin, layoutBottomMargin)
 BASIC_D_READER_IMPL(Worksheet, float, layoutLeftMargin, layoutLeftMargin)
 BASIC_D_READER_IMPL(Worksheet, float, layoutRightMargin, layoutRightMargin)
 BASIC_D_READER_IMPL(Worksheet, float, layoutHorizontalSpacing, layoutHorizontalSpacing)
 BASIC_D_READER_IMPL(Worksheet, float, layoutVerticalSpacing, layoutVerticalSpacing)
 BASIC_D_READER_IMPL(Worksheet, int, layoutRowCount, layoutRowCount)
 BASIC_D_READER_IMPL(Worksheet, int, layoutColumnCount, layoutColumnCount)
 
 CLASS_D_READER_IMPL(Worksheet, QString, theme, theme)
 
 /* ============================ setter methods and undo commands for general options  ===================== */
 void Worksheet::setUseViewSize(bool useViewSize) {
 	if (useViewSize != d->useViewSize) {
 		d->useViewSize = useViewSize;
 		emit useViewSizeRequested();
 	}
 }
 
 STD_SETTER_CMD_IMPL_S(Worksheet, SetScaleContent, bool, scaleContent)
 void Worksheet::setScaleContent(bool scaleContent) {
 	if (scaleContent != d->scaleContent)
 		exec(new WorksheetSetScaleContentCmd(d, scaleContent, ki18n("%1: change \"rescale the content\" property")));
 }
 
 /* ============================ setter methods and undo commands  for background options  ================= */
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundType, PlotArea::BackgroundType, backgroundType, update)
 void Worksheet::setBackgroundType(PlotArea::BackgroundType type) {
 	if (type != d->backgroundType)
 		exec(new WorksheetSetBackgroundTypeCmd(d, type, ki18n("%1: background type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundColorStyle, PlotArea::BackgroundColorStyle, backgroundColorStyle, update)
 void Worksheet::setBackgroundColorStyle(PlotArea::BackgroundColorStyle style) {
 	if (style != d->backgroundColorStyle)
 		exec(new WorksheetSetBackgroundColorStyleCmd(d, style, ki18n("%1: background color style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundImageStyle, PlotArea::BackgroundImageStyle, backgroundImageStyle, update)
 void Worksheet::setBackgroundImageStyle(PlotArea::BackgroundImageStyle style) {
 	if (style != d->backgroundImageStyle)
 		exec(new WorksheetSetBackgroundImageStyleCmd(d, style, ki18n("%1: background image style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundBrushStyle, Qt::BrushStyle, backgroundBrushStyle, update)
 void Worksheet::setBackgroundBrushStyle(Qt::BrushStyle style) {
 	if (style != d->backgroundBrushStyle)
 		exec(new WorksheetSetBackgroundBrushStyleCmd(d, style, ki18n("%1: background brush style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundFirstColor, QColor, backgroundFirstColor, update)
 void Worksheet::setBackgroundFirstColor(const QColor &color) {
 	if (color!= d->backgroundFirstColor)
 		exec(new WorksheetSetBackgroundFirstColorCmd(d, color, ki18n("%1: set background first color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundSecondColor, QColor, backgroundSecondColor, update)
 void Worksheet::setBackgroundSecondColor(const QColor &color) {
 	if (color!= d->backgroundSecondColor)
 		exec(new WorksheetSetBackgroundSecondColorCmd(d, color, ki18n("%1: set background second color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundFileName, QString, backgroundFileName, update)
 void Worksheet::setBackgroundFileName(const QString& fileName) {
 	if (fileName!= d->backgroundFileName)
 		exec(new WorksheetSetBackgroundFileNameCmd(d, fileName, ki18n("%1: set background image")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetBackgroundOpacity, float, backgroundOpacity, update)
 void Worksheet::setBackgroundOpacity(float opacity) {
 	if (opacity != d->backgroundOpacity)
 		exec(new WorksheetSetBackgroundOpacityCmd(d, opacity, ki18n("%1: set opacity")));
 }
 
 /* ============================ setter methods and undo commands  for layout options  ================= */
 STD_SETTER_CMD_IMPL_F_S(Worksheet, SetLayout, Worksheet::Layout, layout, updateLayout)
 void Worksheet::setLayout(Worksheet::Layout layout) {
 	if (layout != d->layout) {
 		beginMacro(i18n("%1: set layout", name()));
 		exec(new WorksheetSetLayoutCmd(d, layout, ki18n("%1: set layout")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutTopMargin, float, layoutTopMargin, updateLayout)
 void Worksheet::setLayoutTopMargin(float margin) {
 	if (margin != d->layoutTopMargin) {
 		beginMacro(i18n("%1: set layout top margin", name()));
 		exec(new WorksheetSetLayoutTopMarginCmd(d, margin, ki18n("%1: set layout top margin")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutBottomMargin, float, layoutBottomMargin, updateLayout)
 void Worksheet::setLayoutBottomMargin(float margin) {
 	if (margin != d->layoutBottomMargin) {
 		beginMacro(i18n("%1: set layout bottom margin", name()));
 		exec(new WorksheetSetLayoutBottomMarginCmd(d, margin, ki18n("%1: set layout bottom margin")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutLeftMargin, float, layoutLeftMargin, updateLayout)
 void Worksheet::setLayoutLeftMargin(float margin) {
 	if (margin != d->layoutLeftMargin) {
 		beginMacro(i18n("%1: set layout left margin", name()));
 		exec(new WorksheetSetLayoutLeftMarginCmd(d, margin, ki18n("%1: set layout left margin")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutRightMargin, float, layoutRightMargin, updateLayout)
 void Worksheet::setLayoutRightMargin(float margin) {
 	if (margin != d->layoutRightMargin) {
 		beginMacro(i18n("%1: set layout right margin", name()));
 		exec(new WorksheetSetLayoutRightMarginCmd(d, margin, ki18n("%1: set layout right margin")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutVerticalSpacing, float, layoutVerticalSpacing, updateLayout)
 void Worksheet::setLayoutVerticalSpacing(float spacing) {
 	if (spacing != d->layoutVerticalSpacing) {
 		beginMacro(i18n("%1: set layout vertical spacing", name()));
 		exec(new WorksheetSetLayoutVerticalSpacingCmd(d, spacing, ki18n("%1: set layout vertical spacing")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutHorizontalSpacing, float, layoutHorizontalSpacing, updateLayout)
 void Worksheet::setLayoutHorizontalSpacing(float spacing) {
 	if (spacing != d->layoutHorizontalSpacing) {
 		beginMacro(i18n("%1: set layout horizontal spacing", name()));
 		exec(new WorksheetSetLayoutHorizontalSpacingCmd(d, spacing, ki18n("%1: set layout horizontal spacing")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutRowCount, int, layoutRowCount, updateLayout)
 void Worksheet::setLayoutRowCount(int count) {
 	if (count != d->layoutRowCount) {
 		beginMacro(i18n("%1: set layout row count", name()));
 		exec(new WorksheetSetLayoutRowCountCmd(d, count, ki18n("%1: set layout row count")));
 		endMacro();
 	}
 }
 
 STD_SETTER_CMD_IMPL_M_F_S(Worksheet, SetLayoutColumnCount, int, layoutColumnCount, updateLayout)
 void Worksheet::setLayoutColumnCount(int count) {
 	if (count != d->layoutColumnCount) {
 		beginMacro(i18n("%1: set layout column count", name()));
 		exec(new WorksheetSetLayoutColumnCountCmd(d, count, ki18n("%1: set layout column count")));
 		endMacro();
 	}
 }
 
 class WorksheetSetPageRectCmd : public StandardMacroSetterCmd<Worksheet::Private, QRectF> {
 public:
 	WorksheetSetPageRectCmd(Worksheet::Private* target, QRectF newValue, const KLocalizedString& description)
 		: StandardMacroSetterCmd<Worksheet::Private, QRectF>(target, &Worksheet::Private::pageRect, newValue, description) {}
 	void finalize() override {
 		m_target->updatePageRect();
 		emit m_target->q->pageRectChanged(m_target->*m_field);
 	}
 	void finalizeUndo() override {
 		m_target->m_scene->setSceneRect(m_target->*m_field);
 		emit m_target->q->pageRectChanged(m_target->*m_field);
 	}
 };
 
 void Worksheet::setPageRect(const QRectF& rect) {
 	//don't allow any rectangulars of width/height equal to zero
 	if (qFuzzyCompare(rect.width(), 0.) || qFuzzyCompare(rect.height(), 0.)) {
 		emit pageRectChanged(d->pageRect);
 		return;
 	}
 
 	if (rect != d->pageRect) {
 		if (!d->useViewSize) {
 			beginMacro(i18n("%1: set page size", name()));
 			exec(new WorksheetSetPageRectCmd(d, rect, ki18n("%1: set page size")));
 			endMacro();
 		} else {
 			d->pageRect = rect;
 			d->updatePageRect();
 			emit pageRectChanged(d->pageRect);
 		}
 	}
 }
 
 void Worksheet::setPrinting(bool on) const {
 	QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 	for (auto* child : childElements)
 		child->setPrinting(on);
 }
 
 STD_SETTER_CMD_IMPL_S(Worksheet, SetTheme, QString, theme)
 void Worksheet::setTheme(const QString& theme) {
 	if (theme != d->theme) {
 		if (!theme.isEmpty()) {
 			beginMacro( i18n("%1: load theme %2", name(), theme) );
 			exec(new WorksheetSetThemeCmd(d, theme, ki18n("%1: set theme")));
 			loadTheme(theme);
 			endMacro();
 		} else {
 			exec(new WorksheetSetThemeCmd(d, theme, ki18n("%1: disable theming")));
 		}
 	}
 }
 
 void Worksheet::cartesianPlotmousePressZoomSelectionMode(QPointF logicPos){
 	if(cartesianPlotActionMode() == Worksheet::ApplyActionToAll){
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 		for (auto* child : childElements){
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
 			if(plot)
 				plot->mousePressZoomSelectionMode(logicPos);
 		}
 		return;
 	}
 	CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	plot->mousePressZoomSelectionMode(logicPos);
 }
 
 void Worksheet::cartesianPlotmouseReleaseZoomSelectionMode(){
 	if(cartesianPlotActionMode() == Worksheet::ApplyActionToAll){
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 		for (auto* child : childElements){
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
 			if(plot)
 				plot->mouseReleaseZoomSelectionMode();
 		}
 		return;
 	}
 	CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	plot->mouseReleaseZoomSelectionMode();
 }
 
 void Worksheet::cartesianPlotmousePressCursorMode(int cursorNumber, QPointF logicPos){
 	if(cartesianPlotCursorMode() == Worksheet::ApplyActionToAll){
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 		for (auto* child : childElements){
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
 			if(plot)
 				plot->mousePressCursorMode(cursorNumber, logicPos);
 		}
 	} else {
 		CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 		if (plot)
 			plot->mousePressCursorMode(cursorNumber, logicPos);
 	}
 
 	cursorPosChanged(cursorNumber, logicPos.x());
 }
 
 void Worksheet::cartesianPlotmouseMoveZoomSelectionMode(QPointF logicPos){
 	if(cartesianPlotActionMode() == Worksheet::ApplyActionToAll){
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 		for (auto* child : childElements){
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
 			if(plot)
 				plot->mouseMoveZoomSelectionMode(logicPos);
 		}
 		return;
 	}
 	CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	plot->mouseMoveZoomSelectionMode(logicPos);
 }
 
 void Worksheet::cartesianPlotmouseHoverZoomSelectionMode(QPointF logicPos) {
 	if(cartesianPlotActionMode() == Worksheet::ApplyActionToAll){
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
 		for (auto* child : childElements){
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
 			if(plot)
 				plot->mouseHoverZoomSelectionMode(logicPos);
 		}
 		return;
 	}
 	CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	plot->mouseHoverZoomSelectionMode(logicPos);
 }
 
 void Worksheet::cartesianPlotmouseMoveCursorMode(int cursorNumber, QPointF logicPos){
 	if (cartesianPlotCursorMode() == Worksheet::ApplyActionToAll) {
 		QVector<WorksheetElement*> childElements = children<WorksheetElement>(AbstractAspect::Recursive | AbstractAspect::IncludeHidden);
         for (auto* child : childElements) {
 			CartesianPlot* plot = dynamic_cast<CartesianPlot*>(child);
             if (plot)
 				plot->mouseMoveCursorMode(cursorNumber, logicPos);
 		}
 	} else {
 		CartesianPlot* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 		plot->mouseMoveCursorMode(cursorNumber, logicPos);
 	}
 
 	cursorPosChanged(cursorNumber, logicPos.x());
 }
 
 /*!
  * \brief Worksheet::cursorPosChanged
  * Updates the cursor treemodel with the new data
  * \param xPos: new position of the cursor
  * It is assumed, that the plots/curves are in the same order than receiving from
  * the children() function. It's not checked if the names are the same
  */
 void Worksheet::cursorPosChanged(int cursorNumber, double xPos){
 
 	if (d->suppressCursorPosChanged)
 		return;
 	TreeModel* treeModel = cursorModel();
 
 	auto* sender = dynamic_cast<CartesianPlot*>(QObject::sender());
 
 	// if ApplyActionToSelection, each plot has it's own x value
 	int rowPlot = 0;
 	if(cartesianPlotCursorMode() == Worksheet::ApplyActionToAll){
 		// x values
 		rowPlot = 1;
 		QModelIndex xName = treeModel->index(0, WorksheetPrivate::TreeModelColumn::SIGNALNAME);
 		treeModel->setData(xName, QVariant("X"));
 		double valueCursor[2];
 		for (int i = 0; i < 2; i++) { // need both cursors to calculate diff
 			valueCursor[i] = sender->cursorPos(i);
 			treeModel->setTreeData(QVariant(valueCursor[i]), 0,
 								   WorksheetPrivate::TreeModelColumn::CURSOR0+i);
 
 		}
 		treeModel->setTreeData(QVariant(valueCursor[1] - valueCursor[0]), 0,
 								WorksheetPrivate::TreeModelColumn::CURSORDIFF);
 
 		// y values
 		for (int i = 0; i < getPlotCount(); i++) { // i=0 is the x Axis
 
 			auto* plot = dynamic_cast<CartesianPlot*>(getPlot(i));
 			if (!plot || !plot->isVisible())
 				continue;
 
 			QModelIndex plotIndex = treeModel->index(rowPlot,
 													 WorksheetPrivate::TreeModelColumn::PLOTNAME);
 
 			// curves
 			int rowCurve = 0;
 			for (int j = 0; j < plot->curveCount(); j++) {
 				// assumption: index of signals in model is the same than the index of the signal in the plot
 				bool valueFound;
 
 				const XYCurve* curve = plot->getCurve(j);
 				if (!curve->isVisible())
 					continue;
 
 				double value = curve->y(xPos, valueFound);
 				if (cursorNumber == 0) {
 					treeModel->setTreeData(QVariant(value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex);
 					double valueCursor1 = treeModel->treeData(rowCurve,
 															  WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex).toDouble();
 					treeModel->setTreeData(QVariant(valueCursor1 - value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 				} else {
 					treeModel->setTreeData(QVariant(value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex);
 					double valueCursor0 = treeModel->treeData(rowCurve,
 															  WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex).toDouble();
 					treeModel->setTreeData(QVariant(value - valueCursor0), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 				}
 				rowCurve++;
 			}
 			rowPlot++;
 		}
 	} else { // apply to selection
 		// assumption: plot is visible
 		int rowCount = treeModel->rowCount();
 		for (int i = 0; i < rowCount; i++) {
 			QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 			if (plotIndex.data().toString().compare(sender->name()) != 0)
 				continue;
 
 			// x values (first row always exist)
 			treeModel->setTreeData(QVariant("X"), 0,
 								   WorksheetPrivate::TreeModelColumn::SIGNALNAME, plotIndex);
 			double valueCursor[2];
 			for (int i = 0; i < 2; i++) { // need both cursors to calculate diff
 				valueCursor[i] = sender->cursorPos(i);
 				treeModel->setTreeData(QVariant(valueCursor[i]), 0,
 									   WorksheetPrivate::TreeModelColumn::CURSOR0+i, plotIndex);
 			}
 			treeModel->setTreeData(QVariant(valueCursor[1]-valueCursor[0]), 0,
 									WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 
 			// y values
 			int rowCurve = 1; // first is x value
 			for (int j = 0; j< sender->curveCount(); j++) { // j=0 are the x values
 
 				const XYCurve* curve = sender->getCurve(j); // -1 because we start with 1 for the x axis
 				if (!curve->isVisible())
 					continue;
 
 				// assumption: index of signals in model is the same than the index of the signal in the plot
 				bool valueFound;
 
 				double value = curve->y(xPos, valueFound);
 				if (cursorNumber == 0) {
 					treeModel->setTreeData(QVariant(value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex);
 					double valueCursor1 = treeModel->treeData(rowCurve,
 															  WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex).toDouble();
 					treeModel->setTreeData(QVariant(valueCursor1 - value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 				} else {
 					treeModel->setTreeData(QVariant(value), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex);
 					double valueCursor0 = treeModel->treeData(rowCurve,
 															  WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex).toDouble();
 					treeModel->setTreeData(QVariant(value - valueCursor0), rowCurve,
 										   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 				}
 				rowCurve++;
 			}
 
 		}
 	}
 }
 
 void Worksheet::cursorModelPlotAdded(QString name) {
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 	// add plot at the end
 	treeModel->insertRows(rowCount, 1); // add empty rows. Then they become filled
 	treeModel->setTreeData(QVariant(name), rowCount, WorksheetPrivate::TreeModelColumn::PLOTNAME); // rowCount instead of rowCount -1 because first row is the x value
 }
 
 void Worksheet::cursorModelPlotRemoved(QString name) {
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 
 	// first is x Axis
 	for (int i = 1; i < rowCount; i++) {
 		QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 		if (plotIndex.data().toString().compare(name) != 0)
 			continue;
 		treeModel->removeRows(plotIndex.row(), 1);
 		return;
 	}
 }
 
 void Worksheet::cartesianPlotmouseModeChanged() {
 	// assumption: only called from a CartesianPlot
 	auto* plot = static_cast<CartesianPlot*>(QObject::sender());
 	if (d->updateCompleteCursorModel) {
 		updateCompleteCursorTreeModel();
 		d->updateCompleteCursorModel = false;
 	}
 
 	// If cursor dock is closed open it only, when the MouseMode is set to cursor.
 	// If it is already open, let it open, so the gui does not change.
 	if (plot->mouseMode() == CartesianPlot::MouseMode::Cursor)
 		emit showCursorDock(cursorModel(), children<CartesianPlot>());
 }
 
 void Worksheet::curveDataChanged(const XYCurve* curve) {
 	auto* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	if (!plot)
 		return;
 
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 
 	for (int i = 0; i < rowCount; i++) {
 		QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 		if (plotIndex.data().toString().compare(plot->name()) != 0)
 			continue;
 
 		for (int j = 0; j < plot->curveCount(); j++) {
 
 			if (plot->getCurve(j)->name().compare(curve->name()) != 0)
 				continue;
 
 			treeModel->setTreeData(QVariant(curve->name()), j,
 								   WorksheetPrivate::TreeModelColumn::SIGNALNAME, plotIndex);
 
 			bool valueFound;
 			double valueCursor0 = curve->y(plot->cursorPos(0), valueFound);
 			treeModel->setTreeData(QVariant(valueCursor0), j,
 								   WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex);
 
 			double valueCursor1 = curve->y(plot->cursorPos(1), valueFound);
 			treeModel->setTreeData(QVariant(valueCursor1), j,
 								   WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex);
 
 			treeModel->setTreeData(QVariant(valueCursor1-valueCursor0), j,
 								   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 			break;
 		}
 		break;
 	}
 }
 
 void Worksheet::curveAdded(const XYCurve* curve) {
 	auto* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	if (!plot)
 		return;
 
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 
 	// first row is the x axis, so starting at the second row
 	for (int i = 1; i < rowCount; i++) {
 		QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 		if (plotIndex.data().toString().compare(plot->name()) != 0)
 			continue;
 
 		for (int j = 0; j < plot->curveCount(); j++) {
 
 			if (plot->getCurve(j)->name().compare(curve->name()) != 0)
 				continue;
 
 			treeModel->insertRow(j, plotIndex);
 
 			QModelIndex curveIndex = treeModel->index(j, WorksheetPrivate::TreeModelColumn::SIGNALNAME,
 													  plotIndex);
 			treeModel->setData(curveIndex, QVariant(curve->name()));
 
 			bool valueFound;
 			double valueCursor0 = curve->y(plot->cursorPos(0), valueFound);
 			treeModel->setTreeData(QVariant(valueCursor0), j,
 								   WorksheetPrivate::TreeModelColumn::CURSOR0, plotIndex);
 
 			double valueCursor1 = curve->y(plot->cursorPos(1), valueFound);
 			treeModel->setTreeData(QVariant(valueCursor1), j,
 								   WorksheetPrivate::TreeModelColumn::CURSOR1, plotIndex);
 
 			treeModel->setTreeData(QVariant(valueCursor1-valueCursor0), j,
 								   WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotIndex);
 			break;
 		}
 		break;
 	}
 }
 
 void Worksheet::curveRemoved(const XYCurve* curve) {
 
 	auto* plot = dynamic_cast<CartesianPlot*>(QObject::sender());
 	if (!plot)
 		return;
 
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 
 	for (int i = 0; i < rowCount; i++) {
 		QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 		if (plotIndex.data().toString().compare(plot->name()) != 0)
 			continue;
 
 		int curveCount = treeModel->rowCount(plotIndex);
 		for (int j = 0; j < curveCount; j++) {
 			QModelIndex curveIndex = treeModel->index(j, WorksheetPrivate::TreeModelColumn::SIGNALNAME,
 													  plotIndex);
 
 			if (curveIndex.data().toString().compare(curve->name()) != 0)
 				continue;
 			treeModel->removeRow(j, plotIndex);
 			break;
 		}
 		break;
 	}
 }
 
 /*!
  * Updates the background of the cuves entry in the treeview
  * @param pen Pen of the curve
  * @param curveName Curve name to find in treemodel
  */
 void Worksheet::updateCurveBackground(QPen pen, QString curveName) {
 	const CartesianPlot* plot = static_cast<const CartesianPlot*>(QObject::sender());
 	TreeModel* treeModel = cursorModel();
 	int rowCount = treeModel->rowCount();
 
 	for (int i = 0; i < rowCount; i++) {
 		QModelIndex plotIndex = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 		if (plotIndex.data().toString().compare(plot->name()) != 0)
 			continue;
 
 		int curveCount = treeModel->rowCount(plotIndex);
 		for (int j = 0; j < curveCount; j++) {
 			QModelIndex curveIndex = treeModel->index(j, WorksheetPrivate::TreeModelColumn::SIGNALNAME,
 													  plotIndex);
 
 			if (curveIndex.data().toString().compare(curveName) != 0)
 				continue;
 
 			QColor curveColor = pen.color();
 			curveColor.setAlpha(50);
 			treeModel->setTreeData(QVariant(curveColor), j,
 								   WorksheetPrivate::TreeModelColumn::SIGNALNAME,
 								   plotIndex, Qt::BackgroundRole);
 			return;
 		}
 		return;
 	}
 }
 
 /**
  * @brief Worksheet::updateCompleteCursorTreeModel
  * If the plot or the curve are not available, the plot/curve is not in the treemodel!
  */
 void Worksheet::updateCompleteCursorTreeModel() {
 	TreeModel* treeModel = cursorModel();
 
 	treeModel->removeRows(0,treeModel->rowCount()); // remove all data
 
 	int plotCount = getPlotCount();
 	if (plotCount < 1)
 		return;
 
 	int rowPlot = 0;
 
 	if (cartesianPlotCursorMode() == Worksheet::CartesianPlotActionMode::ApplyActionToAll) {
 		// 1 because of the X data
 		treeModel->insertRows(0, 1); //, treeModel->index(0,0)); // add empty rows. Then they become filled
 		rowPlot = 1;
 
 		// set X data
 		QModelIndex xName = treeModel->index(0, WorksheetPrivate::TreeModelColumn::SIGNALNAME);
 		treeModel->setData(xName, QVariant("X"));
 		CartesianPlot* plot0 = dynamic_cast<CartesianPlot*>(getPlot(0));
 		double valueCursor[2];
 		for (int i = 0; i < 2; i++) {
 			valueCursor[i] = plot0->cursorPos(i);
 			QModelIndex cursor = treeModel->index(0,WorksheetPrivate::TreeModelColumn::CURSOR0+i);
 
 			treeModel->setData(cursor, QVariant(valueCursor[i]));
 		}
 		QModelIndex diff = treeModel->index(0,WorksheetPrivate::TreeModelColumn::CURSORDIFF);
 		treeModel->setData(diff, QVariant(valueCursor[1]-valueCursor[0]));
 	} else {
 		//treeModel->insertRows(0, plotCount, treeModel->index(0,0)); // add empty rows. Then they become filled
 	}
 
 	// set plot name, y value, background
 	for (int i = 0; i < plotCount; i++) {
 		CartesianPlot* plot = dynamic_cast<CartesianPlot*>(getPlot(i));
 		QModelIndex plotName;
 		int addOne = 0;
 
 		if (!plot || !plot->isVisible())
 			continue;
 
 		// add new entry for the plot
 		treeModel->insertRows(treeModel->rowCount(), 1); //, treeModel->index(0, 0));
 
 		if (cartesianPlotCursorMode() == Worksheet::CartesianPlotActionMode::ApplyActionToAll) {
 			plotName = treeModel->index(i + 1, WorksheetPrivate::TreeModelColumn::PLOTNAME); // plus one because first row are the x values
 			treeModel->setData(plotName, QVariant(plot->name()));
 		} else {
 			addOne = 1;
 			plotName = treeModel->index(i, WorksheetPrivate::TreeModelColumn::PLOTNAME);
 			treeModel->setData(plotName, QVariant(plot->name()));
 			treeModel->insertRows(0, 1, plotName); // one, because the first row are the x values
 
 			QModelIndex xName = treeModel->index(0, WorksheetPrivate::TreeModelColumn::SIGNALNAME, plotName);
 			treeModel->setData(xName, QVariant("X"));
 			double valueCursor[2];
 			for (int i = 0; i < 2; i++) {
 				valueCursor[i] = plot->cursorPos(i);
 				QModelIndex cursor = treeModel->index(0, WorksheetPrivate::TreeModelColumn::CURSOR0+i, plotName);
 
 				treeModel->setData(cursor, QVariant(valueCursor[i]));
 			}
 			QModelIndex diff = treeModel->index(0, WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotName);
 			treeModel->setData(diff, QVariant(valueCursor[1]-valueCursor[0]));
 		}
 
 
 		int rowCurve = addOne;
 		for (int j = 0; j < plot->curveCount(); j++) {
 			double cursorValue[2] = {NAN, NAN};
 			const XYCurve* curve = plot->getCurve(j);
 
 			if (!curve->isVisible())
 				continue;
 
 			for (int k = 0; k < 2; k++) {
 				double xPos = plot->cursorPos(k);
 				bool valueFound;
 				cursorValue[k] = curve->y(xPos,valueFound);
 			}
 			treeModel->insertRows(rowCurve, 1, plotName);
 			QModelIndex backgroundColor = treeModel->index(rowCurve, 0, plotName);
 			QColor curveColor = curve->linePen().color();
 			curveColor.setAlpha(50);
 			treeModel->setData(backgroundColor, QVariant(curveColor), Qt::BackgroundRole);
 			QModelIndex signalName = treeModel->index(rowCurve, WorksheetPrivate::TreeModelColumn::SIGNALNAME, plotName);
 			treeModel->setData(signalName, QVariant(curve->name()));
 			QModelIndex signalCursor0 = treeModel->index(rowCurve, WorksheetPrivate::TreeModelColumn::CURSOR0, plotName);
 			treeModel->setData(signalCursor0, QVariant(cursorValue[0]));
 			QModelIndex signalCursor2 = treeModel->index(rowCurve, WorksheetPrivate::TreeModelColumn::CURSOR1, plotName);
 			treeModel->setData(signalCursor2, QVariant(cursorValue[1]));
 			QModelIndex differenceValues = treeModel->index(rowCurve, WorksheetPrivate::TreeModelColumn::CURSORDIFF, plotName);
 			treeModel->setData(differenceValues, QVariant(cursorValue[1]-cursorValue[0]));
 
 			rowCurve++;
 		}
 		rowPlot++;
 	}
 }
 
 //##############################################################################
 //######################  Private implementation ###############################
 //##############################################################################
 WorksheetPrivate::WorksheetPrivate(Worksheet* owner) : q(owner), m_scene(new QGraphicsScene()) {
 	QStringList headers = {i18n("Plot/Curve"), "V1", "V2", "V2-V1"};
     cursorData = new TreeModel(headers, nullptr);
 }
 
 QString WorksheetPrivate::name() const {
 	return q->name();
 }
 
 /*!
  * called if the worksheet page (the actual size of worksheet's rectangular) was changed.
  * if a layout is active, it is is updated - this adjusts the sizes of the elements in the layout to the new page size.
  * if no layout is active and the option "scale content" is active, \c handleResize() is called to adjust zhe properties.
  */
 void WorksheetPrivate::updatePageRect() {
 	if (q->isLoading())
 		return;
 
 	QRectF oldRect = m_scene->sceneRect();
 	m_scene->setSceneRect(pageRect);
 
 	if (layout != Worksheet::NoLayout)
 		updateLayout();
 	else {
 		if (scaleContent) {
 			qreal horizontalRatio = pageRect.width() / oldRect.width();
 			qreal verticalRatio = pageRect.height() / oldRect.height();
 			QVector<WorksheetElement*> childElements = q->children<WorksheetElement>(AbstractAspect::IncludeHidden);
 			if (useViewSize) {
 				//don't make the change of the geometry undoable/redoable if the view size is used.
 				for (auto* elem : childElements) {
 					elem->setUndoAware(false);
 					elem->handleResize(horizontalRatio, verticalRatio, true);
 					elem->setUndoAware(true);
 				}
 			} else {
 // 				for (auto* child : childElements)
 // 					child->handleResize(horizontalRatio, verticalRatio, true);
 			}
 		}
 	}
 }
 
 void WorksheetPrivate::update() {
 	q->update();
 }
 
 WorksheetPrivate::~WorksheetPrivate() {
 	delete m_scene;
 }
 
 void WorksheetPrivate::updateLayout(bool undoable) {
 	if (suppressLayoutUpdate)
 		return;
 
 	QVector<WorksheetElementContainer*> list = q->children<WorksheetElementContainer>();
 	if (layout == Worksheet::NoLayout) {
 		for (auto* elem : list)
 			elem->graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, true);
 
 		return;
 	}
 
 	float x = layoutLeftMargin;
 	float y = layoutTopMargin;
 	float w, h;
 	int count = list.count();
 	if (layout == Worksheet::VerticalLayout) {
 		w = m_scene->sceneRect().width() - layoutLeftMargin - layoutRightMargin;
 		h = (m_scene->sceneRect().height()-layoutTopMargin-layoutBottomMargin- (count-1)*layoutVerticalSpacing)/count;
 		for (auto* elem : list) {
 			setContainerRect(elem, x, y, h, w, undoable);
 			y += h + layoutVerticalSpacing;
 		}
 	} else if (layout == Worksheet::HorizontalLayout) {
 		w = (m_scene->sceneRect().width()-layoutLeftMargin-layoutRightMargin- (count-1)*layoutHorizontalSpacing)/count;
 		h = m_scene->sceneRect().height() - layoutTopMargin-layoutBottomMargin;
 		for (auto* elem : list) {
 			setContainerRect(elem, x, y, h, w, undoable);
 			x += w + layoutHorizontalSpacing;
 		}
 	} else { //GridLayout
 		//add new rows, if not sufficient
 		if (count > layoutRowCount*layoutColumnCount) {
 			layoutRowCount = floor( (float)count/layoutColumnCount + 0.5);
 			emit q->layoutRowCountChanged(layoutRowCount);
 		}
 
 		w = (m_scene->sceneRect().width()-layoutLeftMargin-layoutRightMargin- (layoutColumnCount-1)*layoutHorizontalSpacing)/layoutColumnCount;
 		h = (m_scene->sceneRect().height()-layoutTopMargin-layoutBottomMargin- (layoutRowCount-1)*layoutVerticalSpacing)/layoutRowCount;
 		int columnIndex = 0; //counts the columns in a row
 		for (auto* elem : list) {
 			setContainerRect(elem, x, y, h, w, undoable);
 			x += w + layoutHorizontalSpacing;
 			columnIndex++;
 			if (columnIndex == layoutColumnCount) {
 				columnIndex = 0;
 				x = layoutLeftMargin;
 				y += h + layoutVerticalSpacing;
 			}
 		}
 	}
 }
 
 void WorksheetPrivate::setContainerRect(WorksheetElementContainer* elem, float x, float y, float h, float w, bool undoable) {
 	if (useViewSize) {
 		//when using the view size, no need to put rect changes onto the undo-stack
 		elem->setUndoAware(false);
 		elem->setRect(QRectF(x,y,w,h));
 		elem->setUndoAware(true);
 	} else {
 		//don't put rect changed onto the undo-stack if undoable-flag is set to true,
 		//e.g. when new child is added or removed (the layout and the childrend rects will be updated anyway)
 		if (!undoable) {
 			elem->setUndoAware(false);
 			elem->setRect(QRectF(x,y,w,h));
 			elem->setUndoAware(true);
 		} else
 			elem->setRect(QRectF(x,y,w,h));
 	}
 	elem->graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 
 //! Save as XML
 void Worksheet::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement( "worksheet" );
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//applied theme
 	if (!d->theme.isEmpty()) {
 		writer->writeStartElement( "theme" );
 		writer->writeAttribute("name", d->theme);
 		writer->writeEndElement();
 	}
 
 	//geometry
 	writer->writeStartElement( "geometry" );
 	QRectF rect = d->m_scene->sceneRect();
 	writer->writeAttribute( "x", QString::number(rect.x()) );
 	writer->writeAttribute( "y", QString::number(rect.y()) );
 	writer->writeAttribute( "width", QString::number(rect.width()) );
 	writer->writeAttribute( "height", QString::number(rect.height()) );
 	writer->writeAttribute( "useViewSize", QString::number(d->useViewSize) );
 	writer->writeEndElement();
 
 	//layout
 	writer->writeStartElement( "layout" );
 	writer->writeAttribute( "layout", QString::number(d->layout) );
 	writer->writeAttribute( "topMargin", QString::number(d->layoutTopMargin) );
 	writer->writeAttribute( "bottomMargin", QString::number(d->layoutBottomMargin) );
 	writer->writeAttribute( "leftMargin", QString::number(d->layoutLeftMargin) );
 	writer->writeAttribute( "rightMargin", QString::number(d->layoutRightMargin) );
 	writer->writeAttribute( "verticalSpacing", QString::number(d->layoutVerticalSpacing) );
 	writer->writeAttribute( "horizontalSpacing", QString::number(d->layoutHorizontalSpacing) );
 	writer->writeAttribute( "columnCount", QString::number(d->layoutColumnCount) );
 	writer->writeAttribute( "rowCount", QString::number(d->layoutRowCount) );
 	writer->writeEndElement();
 
 	//background properties
 	writer->writeStartElement( "background" );
 	writer->writeAttribute( "type", QString::number(d->backgroundType) );
 	writer->writeAttribute( "colorStyle", QString::number(d->backgroundColorStyle) );
 	writer->writeAttribute( "imageStyle", QString::number(d->backgroundImageStyle) );
 	writer->writeAttribute( "brushStyle", QString::number(d->backgroundBrushStyle) );
 	writer->writeAttribute( "firstColor_r", QString::number(d->backgroundFirstColor.red()) );
 	writer->writeAttribute( "firstColor_g", QString::number(d->backgroundFirstColor.green()) );
 	writer->writeAttribute( "firstColor_b", QString::number(d->backgroundFirstColor.blue()) );
 	writer->writeAttribute( "secondColor_r", QString::number(d->backgroundSecondColor.red()) );
 	writer->writeAttribute( "secondColor_g", QString::number(d->backgroundSecondColor.green()) );
 	writer->writeAttribute( "secondColor_b", QString::number(d->backgroundSecondColor.blue()) );
 	writer->writeAttribute( "fileName", d->backgroundFileName );
 	writer->writeAttribute( "opacity", QString::number(d->backgroundOpacity) );
 	writer->writeEndElement();
 
 	// cartesian properties
 	writer->writeStartElement( "plotProperties" );
 	writer->writeAttribute( "plotsLocked", QString::number(d->plotsLocked) );
 	writer->writeAttribute( "cartesianPlotActionMode", QString::number(d->cartesianPlotActionMode));
 	writer->writeAttribute( "cartesianPlotCursorMode", QString::number(d->cartesianPlotCursorMode));
 	writer->writeEndElement();
 
 	//serialize all children
 	for (auto* child : children<WorksheetElement>(IncludeHidden))
 		child->save(writer);
 
 	writer->writeEndElement(); // close "worksheet" section
 }
 
 //! Load from XML
 bool Worksheet::load(XmlStreamReader* reader, bool preview) {
 	if (!readBasicAttributes(reader))
 		return false;
 
 	//clear the theme that was potentially set in init() in order to correctly load here the worksheets without any theme used
 	d->theme.clear();
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 	QRectF rect;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "worksheet")
 			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
 				rect.setX(str.toDouble());
 
 			str = attribs.value("y").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("y").toString());
 			else
 				rect.setY(str.toDouble());
 
 			str = attribs.value("width").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("width").toString());
 			else
 				rect.setWidth(str.toDouble());
 
 			str = attribs.value("height").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("height").toString());
 			else
 				rect.setHeight(str.toDouble());
 
 			READ_INT_VALUE("useViewSize", useViewSize, int);
 		} else if (!preview && reader->name() == "layout") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("layout", layout, Worksheet::Layout);
 			READ_DOUBLE_VALUE("topMargin", layoutTopMargin);
 			READ_DOUBLE_VALUE("bottomMargin", layoutBottomMargin);
 			READ_DOUBLE_VALUE("leftMargin", layoutLeftMargin);
 			READ_DOUBLE_VALUE("rightMargin", layoutRightMargin);
 			READ_DOUBLE_VALUE("verticalSpacing", layoutVerticalSpacing);
 			READ_DOUBLE_VALUE("horizontalSpacing", layoutHorizontalSpacing);
 			READ_INT_VALUE("columnCount", layoutColumnCount, int);
 			READ_INT_VALUE("rowCount", layoutRowCount, int);
 		} else if (!preview && reader->name() == "background") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", backgroundType, PlotArea::BackgroundType);
 			READ_INT_VALUE("colorStyle", backgroundColorStyle, PlotArea::BackgroundColorStyle);
 			READ_INT_VALUE("imageStyle", backgroundImageStyle, PlotArea::BackgroundImageStyle);
 			READ_INT_VALUE("brushStyle", backgroundBrushStyle, Qt::BrushStyle);
 
 			str = attribs.value("firstColor_r").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_r").toString());
 			else
 				d->backgroundFirstColor.setRed(str.toInt());
 
 			str = attribs.value("firstColor_g").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_g").toString());
 			else
 				d->backgroundFirstColor.setGreen(str.toInt());
 
 			str = attribs.value("firstColor_b").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_b").toString());
 			else
 				d->backgroundFirstColor.setBlue(str.toInt());
 
 			str = attribs.value("secondColor_r").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_r").toString());
 			else
 				d->backgroundSecondColor.setRed(str.toInt());
 
 			str = attribs.value("secondColor_g").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_g").toString());
 			else
 				d->backgroundSecondColor.setGreen(str.toInt());
 
 			str = attribs.value("secondColor_b").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_b").toString());
 			else
 				d->backgroundSecondColor.setBlue(str.toInt());
 
 			str = attribs.value("fileName").toString();
 			d->backgroundFileName = str;
 
 			READ_DOUBLE_VALUE("opacity", backgroundOpacity);
 		} else if(!preview && reader->name() == "plotProperties") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("plotsLocked", plotsLocked, bool);
 			READ_INT_VALUE("cartesianPlotActionMode", cartesianPlotActionMode, Worksheet::CartesianPlotActionMode);
 			READ_INT_VALUE("cartesianPlotCursorMode", cartesianPlotCursorMode, Worksheet::CartesianPlotActionMode);
 		} else if (reader->name() == "cartesianPlot") {
 			CartesianPlot* plot = new CartesianPlot(QString());
 			plot->setIsLoading(true);
 			if (!plot->load(reader, preview)) {
 				delete plot;
 				return false;
 			} else
 				addChildFast(plot);
 		} else if (reader->name() == "textLabel") {
 			TextLabel* label = new TextLabel(QString());
 			if (!label->load(reader, preview)) {
 				delete label;
 				return false;
 			} else
 				addChildFast(label);
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	if (!preview) {
 		d->m_scene->setSceneRect(rect);
 		d->updateLayout();
 	}
 
     // when creating a new CartesianPlot, this plot sends, that new XYCurves where added,
     // but after creating the CartesianPlot, the CartesianPlot will be added to the Worksheet,
     // where all connections to the signals will be made. So no update will be done automatically
     updateCompleteCursorTreeModel();
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void Worksheet::loadTheme(const QString& theme) {
 	KConfig config(ThemeHandler::themeFilePath(theme), KConfig::SimpleConfig);
 
 	//apply the same background color for Worksheet as for the CartesianPlot
 	const KConfigGroup group = config.group("CartesianPlot");
 	this->setBackgroundBrushStyle((Qt::BrushStyle)group.readEntry("BackgroundBrushStyle",(int) this->backgroundBrushStyle()));
 	this->setBackgroundColorStyle((PlotArea::BackgroundColorStyle)(group.readEntry("BackgroundColorStyle",(int) this->backgroundColorStyle())));
 	this->setBackgroundFirstColor(group.readEntry("BackgroundFirstColor",(QColor) this->backgroundFirstColor()));
 	this->setBackgroundImageStyle((PlotArea::BackgroundImageStyle)group.readEntry("BackgroundImageStyle",(int) this->backgroundImageStyle()));
 	this->setBackgroundOpacity(group.readEntry("BackgroundOpacity", this->backgroundOpacity()));
 	this->setBackgroundSecondColor(group.readEntry("BackgroundSecondColor",(QColor) this->backgroundSecondColor()));
 	this->setBackgroundType((PlotArea::BackgroundType)(group.readEntry("BackgroundType",(int) this->backgroundType())));
 
 	//load the theme for all the children
 	const QVector<WorksheetElement*>& childElements = children<WorksheetElement>(AbstractAspect::IncludeHidden);
 	for (auto* child : childElements)
 		child->loadThemeConfig(config);
 }
diff --git a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
index 423db0b77..40d04755f 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
@@ -1,3610 +1,3610 @@
 /***************************************************************************
     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 <QWidgetAction>
 
 #include <cmath>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 /**
  * \class CartesianPlot
  * \brief A xy-plot.
  *
  *
  */
 CartesianPlot::CartesianPlot(const QString &name)
 	: AbstractPlot(name, new CartesianPlotPrivate(this), AspectType::CartesianPlot) {
 
 	init();
 }
 
 CartesianPlot::CartesianPlot(const QString &name, CartesianPlotPrivate *dd)
 	: AbstractPlot(name, dd, AspectType::CartesianPlot) {
 
 	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->rangeFirstValues = 1000;
 	d->rangeLastValues = 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() + QLatin1String("- ") + i18n("Title"), 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);
 	d->rightPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->bottomPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->symmetricPadding = true;
 
 	connect(this, &AbstractAspect::aspectAdded, this, &CartesianPlot::childAdded);
 	connect(this, &AbstractAspect::aspectRemoved, this, &CartesianPlot::childRemoved);
 
 	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.0;
 			d->xMax = 1.0;
 			d->yMin = 0.0;
 			d->yMax = 1.0;
 
 			//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);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMinorGridPen(pen);
 			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);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setLabelsPosition(Axis::NoLabels);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxes: {
 			d->xMin = 0.0;
 			d->xMax = 1.0;
 			d->yMin = 0.0;
 			d->yMax = 1.0;
 
 			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);
 	d->retransform();
 }
 
 void CartesianPlot::initActions() {
 	//"add new" actions
 	addCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("xy-curve"), this);
 	addHistogramAction = new QAction(QIcon::fromTheme("view-object-histogram-linear"), 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 Auto-/Cross-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 auto-/cross-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, &QAction::triggered, this, &CartesianPlot::addCurve);
 	connect(addHistogramAction,&QAction::triggered, this, &CartesianPlot::addHistogram);
 	connect(addEquationCurveAction, &QAction::triggered, this, &CartesianPlot::addEquationCurve);
 	connect(addDataReductionCurveAction, &QAction::triggered, this, &CartesianPlot::addDataReductionCurve);
 	connect(addDifferentiationCurveAction, &QAction::triggered, this, &CartesianPlot::addDifferentiationCurve);
 	connect(addIntegrationCurveAction, &QAction::triggered, this, &CartesianPlot::addIntegrationCurve);
 	connect(addInterpolationCurveAction, &QAction::triggered, this, &CartesianPlot::addInterpolationCurve);
 	connect(addSmoothCurveAction, &QAction::triggered, this, &CartesianPlot::addSmoothCurve);
 	connect(addFitCurveAction, &QAction::triggered, this, &CartesianPlot::addFitCurve);
 	connect(addFourierFilterCurveAction, &QAction::triggered, this, &CartesianPlot::addFourierFilterCurve);
 	connect(addFourierTransformCurveAction, &QAction::triggered, this, &CartesianPlot::addFourierTransformCurve);
 	connect(addConvolutionCurveAction, &QAction::triggered, this, &CartesianPlot::addConvolutionCurve);
 	connect(addCorrelationCurveAction, &QAction::triggered, this, &CartesianPlot::addCorrelationCurve);
 
 	connect(addLegendAction, &QAction::triggered, this, static_cast<void (CartesianPlot::*)()>(&CartesianPlot::addLegend));
 	connect(addHorizontalAxisAction, &QAction::triggered, this, &CartesianPlot::addHorizontalAxis);
 	connect(addVerticalAxisAction, &QAction::triggered, this, &CartesianPlot::addVerticalAxis);
 	connect(addTextLabelAction, &QAction::triggered, this, &CartesianPlot::addTextLabel);
 	connect(addCustomPointAction, &QAction::triggered, this, &CartesianPlot::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("Auto-/Cross-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, &QAction::triggered, this, &CartesianPlot::addDataReductionCurve);
 	connect(addDifferentiationAction, &QAction::triggered, this, &CartesianPlot::addDifferentiationCurve);
 	connect(addIntegrationAction, &QAction::triggered, this, &CartesianPlot::addIntegrationCurve);
 	connect(addInterpolationAction, &QAction::triggered, this, &CartesianPlot::addInterpolationCurve);
 	connect(addSmoothAction, &QAction::triggered, this, &CartesianPlot::addSmoothCurve);
 	connect(addConvolutionAction, &QAction::triggered, this, &CartesianPlot::addConvolutionCurve);
 	connect(addCorrelationAction, &QAction::triggered, this, &CartesianPlot::addCorrelationCurve);
 	for (const auto& action : addFitAction)
 		connect(action, &QAction::triggered, this, &CartesianPlot::addFitCurve);
 	connect(addFourierFilterAction, &QAction::triggered, this, &CartesianPlot::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);
 	cursorAction = new QAction(QIcon::fromTheme("labplot-shift-down-y"),i18n("Cursor"), this); // TODO: change icon
 
 	connect(scaleAutoAction, &QAction::triggered, this, &CartesianPlot::scaleAuto);
 	connect(scaleAutoXAction, &QAction::triggered, this, &CartesianPlot::scaleAutoX);
 	connect(scaleAutoYAction, &QAction::triggered, this, &CartesianPlot::scaleAutoY);
 	connect(zoomInAction, &QAction::triggered, this, &CartesianPlot::zoomIn);
 	connect(zoomOutAction, &QAction::triggered, this, &CartesianPlot::zoomOut);
 	connect(zoomInXAction, &QAction::triggered, this, &CartesianPlot::zoomInX);
 	connect(zoomOutXAction, &QAction::triggered, this, &CartesianPlot::zoomOutX);
 	connect(zoomInYAction, &QAction::triggered, this, &CartesianPlot::zoomInY);
 	connect(zoomOutYAction, &QAction::triggered, this, &CartesianPlot::zoomOutY);
 	connect(shiftLeftXAction, &QAction::triggered, this, &CartesianPlot::shiftLeftX);
 	connect(shiftRightXAction, &QAction::triggered, this, &CartesianPlot::shiftRightX);
 	connect(shiftUpYAction, &QAction::triggered, this, &CartesianPlot::shiftUpY);
 	connect(shiftDownYAction, &QAction::triggered, this, &CartesianPlot::shiftDownY);
 	connect(cursorAction, &QAction::triggered, this, &CartesianPlot::cursor);
 
 	//visibility action
 	visibilityAction = new QAction(QIcon::fromTheme("view-visible"), i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, &QAction::triggered, this, &CartesianPlot::visibilityChanged);
 }
 
 void CartesianPlot::initMenus() {
 	initActions();
 
 	addNewMenu = new QMenu(i18n("Add New"));
 	addNewMenu->setIcon(QIcon::fromTheme("list-add"));
 	addNewMenu->addAction(addCurveAction);
 	addNewMenu->addAction(addHistogramAction);
 	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->setIcon(QIcon::fromTheme("zoom-draw"));
 	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"));
 	themeMenu->setIcon(QIcon::fromTheme("color-management"));
 	auto* themeWidget = new ThemesWidget(nullptr);
 	connect(themeWidget, &ThemesWidget::themeSelected, this, &CartesianPlot::loadTheme);
 	connect(themeWidget, &ThemesWidget::themeSelected, themeMenu, &QMenu::close);
 
 	auto* 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 a : vec) {
 		auto* aspect = (AbstractAspect*)a;
 		auto* 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, QPen, cursorPen, cursorPen);
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, bool, cursor0Enable, cursor0Enable);
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, bool, cursor1Enable, cursor1Enable);
 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 {
 // 		const double horizontalRatio = m_rect.width() / m_private->rect.width();
 // 		const double verticalRatio = m_rect.height() / m_private->rect.height();
 
 		qSwap(m_private->rect, m_rect);
 
 // 		m_private->q->handleResize(horizontalRatio, verticalRatio, false);
 		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 && xMin != -INFINITY && xMin != INFINITY)
 		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 && xMax != -INFINITY && xMax != INFINITY)
 		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_F_S(CartesianPlot, SetCursorPen, QPen, cursorPen, update)
 void CartesianPlot::setCursorPen(const QPen &pen) {
     Q_D(CartesianPlot);
     if (pen != d->cursorPen)
         exec(new CartesianPlotSetCursorPenCmd(d, pen, ki18n("%1: y-range breaks changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetCursor0Enable, bool, cursor0Enable, updateCursor)
 void CartesianPlot::setCursor0Enable(const bool &enable) {
 	Q_D(CartesianPlot);
 	if (enable != d->cursor0Enable) {
 		if (std::isnan(d->cursor0Pos.x())) { // if never set, set initial position
 			d->cursor0Pos.setX(d->cSystem->mapSceneToLogical(QPointF(0,0)).x());
 			mousePressCursorModeSignal(0, d->cursor0Pos); // simulate mousePress to update values in the cursor dock
 		}
 		exec(new CartesianPlotSetCursor0EnableCmd(d, enable, ki18n("%1: Cursor0 enable")));
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetCursor1Enable, bool, cursor1Enable, updateCursor)
 void CartesianPlot::setCursor1Enable(const bool &enable) {
 	Q_D(CartesianPlot);
 	if (enable != d->cursor1Enable) {
 		if (std::isnan(d->cursor1Pos.x())) { // if never set, set initial position
 			d->cursor1Pos.setX(d->cSystem->mapSceneToLogical(QPointF(0,0)).x());
 			mousePressCursorModeSignal(1, d->cursor0Pos); // simulate mousePress to update values in the cursor dock
 		}
 		exec(new CartesianPlotSetCursor1EnableCmd(d, enable, ki18n("%1: Cursor1 enable")));
 	}
 }
 
 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>()) {
 		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 auto* 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());
 		}
 
 		curve->recalculate();
 
 		//add the child after the fit was calculated so the dock widgets gets the fit results
 		//and call retransform() after this to calculate and to paint the data points of the fit-curve
 		this->addChild(curve);
 		curve->retransform();
 	} 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("Auto-/Cross-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);
 }
 
 int CartesianPlot::curveCount(){
 	return children<XYCurve>().length();
 }
 
 const XYCurve* CartesianPlot::getCurve(int index){
 	return children<XYCurve>()[index];
 }
 
 double CartesianPlot::cursorPos(int cursorNumber) {
     Q_D(CartesianPlot);
     if (cursorNumber == 0)
         return d->cursor0Pos.x();
     else
         return d->cursor1Pos.x();
 }
 
 void CartesianPlot::childAdded(const AbstractAspect* child) {
 	Q_D(CartesianPlot);
 	const auto* curve = qobject_cast<const XYCurve*>(child);
 	if (curve) {
 		connect(curve, &XYCurve::dataChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::xDataChanged, this, &CartesianPlot::xDataChanged);
 		connect(curve, &XYCurve::yDataChanged, this, &CartesianPlot::yDataChanged);
 		connect(curve, static_cast<void (XYCurve::*)(bool)>(&XYCurve::visibilityChanged),
 				this, &CartesianPlot::curveVisibilityChanged);
 
 		//update the legend on changes of the name, line and symbol styles
 		connect(curve, &XYCurve::aspectDescriptionChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::lineTypeChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::linePenChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::lineOpacityChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsStyleChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsSizeChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsRotationAngleChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsOpacityChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsBrushChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsPenChanged, this, &CartesianPlot::updateLegend);
-        connect(curve, SIGNAL(linePenChanged(QPen)), this, SIGNAL(curveLinePenChanged(QPen))); // feed forward linePenChanged, because Worksheet needs because CursorDock must be updated too
+		connect(curve, SIGNAL(linePenChanged(QPen)), this, SIGNAL(curveLinePenChanged(QPen))); // feed forward linePenChanged, because Worksheet needs because CursorDock must be updated too
 
 		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 auto* 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) {
 							auto* 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) {
 							auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 							d->yRangeDateTimeFormat = filter->format();
 							axis->setUndoAware(false);
 							axis->setLabelsDateTimeFormat(d->yRangeDateTimeFormat);
 							axis->setUndoAware(true);
 						}
 					}
 				}
 			}
 		}
         emit curveAdded(curve);
 
 	} else {
 		const auto* hist = qobject_cast<const Histogram*>(child);
 		if (hist) {
 			connect(hist, &Histogram::dataChanged, this, &CartesianPlot::dataChanged);
 			connect(hist, &Histogram::visibilityChanged, this, &CartesianPlot::curveVisibilityChanged);
 
 			updateLegend();
 		}
 		// if an element is hovered, the curves which are handled manually in this class
 		// must be unhovered
 		const WorksheetElement* element = static_cast<const WorksheetElement*>(child);
 		connect(element, &WorksheetElement::hovered, this, &CartesianPlot::childHovered);
 	}
 
 	if (!isLoading()) {
 		//if a theme was selected, apply the theme settings for newly added children, too
 		if (!d->theme.isEmpty()) {
 			const auto* elem = dynamic_cast<const WorksheetElement*>(child);
 			if (elem) {
 				KConfig config(ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig);
 				const_cast<WorksheetElement*>(elem)->loadThemeConfig(config);
 			}
 		} else {
 			//no theme is available, apply the default colors for curves only, s.a. XYCurve::loadThemeConfig()
 			const auto* 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();
 				}
 
 				auto* 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 auto* curve = qobject_cast<const XYCurve*>(child);
         if (curve) {
 			updateLegend();
 			emit curveRemoved(curve);
         }
 	}
 }
 
 /*!
  * \brief CartesianPlot::childHovered
  * Unhover all curves, when another child is hovered. The hover handling for the curves is done in their parent (CartesianPlot),
  * because the hover should set when the curve is hovered and not just the bounding rect (for more see hoverMoveEvent)
  */
 void CartesianPlot::childHovered() {
 	Q_D(CartesianPlot);
 	bool curveSender = dynamic_cast<XYCurve*>(QObject::sender()) != nullptr;
 	if (!d->isSelected()) {
 		if (d->m_hovered)
 			d->m_hovered = false;
 		d->update();
 	}
 	if (!curveSender) {
 		for (auto curve: children<XYCurve>())
 			curve->setHover(false);
 	}
 }
 
 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;
 	bool updated = false;
 	if (d->autoScaleX && d->autoScaleY)
 		updated = this->scaleAuto();
 	else if (d->autoScaleX)
 		updated = this->scaleAutoX();
 	else if (d->autoScaleY)
 		updated = this->scaleAutoY();
 
 	if (!updated || !QObject::sender()) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->retransform();
 			else {
 				//no sender available, the function was called in CartesianPlot::dataChanged()
 				//via plot->dataChaged() in the file filter (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>()) {
 					c->recalcLogicalPoints();
 					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() && project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesXMinMaxIsDirty = true;
 	bool updated = false;
 	if (d->autoScaleX)
 		updated = this->scaleAutoX();
 
 	if (!updated) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->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) {
 		auto* 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);
 		}
 	}
     emit curveDataChanged(dynamic_cast<XYCurve*>(QObject::sender()));
 }
 
 /*!
 	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() && project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesYMinMaxIsDirty = true;
 	bool updated = false;
 	if (d->autoScaleY)
 		this->scaleAutoY();
 
 	if (!updated) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->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) {
 		auto* 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);
 		}
 	}
     emit curveDataChanged(dynamic_cast<XYCurve*>(QObject::sender()));
 }
 
 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();
 
 	emit curveVisibilityChangedSignal();
 }
 
 void CartesianPlot::curveLinePenChanged(QPen pen) {
 	const auto* curve = qobject_cast<const XYCurve*>(QObject::sender());
 	emit curveLinePenChanged(pen, curve->name());
 }
 
 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)
 			item->setFlag(QGraphicsItem::ItemStacksBehindParent, false);
 	} else {
 		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 auto* 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);
 	}
 
 	emit mouseModeChanged();
 }
 
 void CartesianPlot::setLocked(bool locked) {
 	Q_D(CartesianPlot);
 	d->locked = locked;
 }
 
 bool 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>()) {
 			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>()) {
 			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;
 		}
 		setAutoScaleX(true);
 		d->retransformScales();
 	}
 
 	return update;
 }
 
 bool 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>()) {
 			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>()) {
 			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;
 		}
 		setAutoScaleY(true);
 		d->retransformScales();
 	}
 
 	return update;
 }
 
 bool 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>()) {
 			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>()) {
 			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>()) {
 			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>()) {
 			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;
 			}
 			setAutoScaleX(true);
 		}
 		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;
 			}
 			setAutoScaleY(true);
 		}
 		d->retransformScales();
 	}
 
 	return (updateX || updateY);
 }
 
 void CartesianPlot::zoomIn() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	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);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	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);
 
 	setAutoScaleX(false);
 	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);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	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);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	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);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	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);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax -= offsetX;
 	d->xMin -= offsetX;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftRightX() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax += offsetX;
 	d->xMin += offsetX;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftUpY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax += offsetY;
 	d->yMin += offsetY;
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftDownY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax -= offsetY;
 	d->yMin -= offsetY;
 	d->retransformScales();
 }
 
 void CartesianPlot::cursor() {
 	Q_D(CartesianPlot);
 	d->retransformScales();
 }
 
 void CartesianPlot::mousePressZoomSelectionMode(QPointF logicPos){
 	Q_D(CartesianPlot);
 	d->mousePressZoomSelectionMode(logicPos);
 }
 void CartesianPlot::mousePressCursorMode(int cursorNumber, QPointF logicPos){
 	Q_D(CartesianPlot);
 	d->mousePressCursorMode(cursorNumber, logicPos);
 }
 void CartesianPlot::mouseMoveZoomSelectionMode(QPointF logicPos){
 	Q_D(CartesianPlot);
 	d->mouseMoveZoomSelectionMode(logicPos);
 }
 void CartesianPlot::mouseMoveCursorMode(int cursorNumber, QPointF logicPos){
 	Q_D(CartesianPlot);
 	d->mouseMoveCursorMode(cursorNumber, logicPos);
 }
 
 void CartesianPlot::mouseReleaseZoomSelectionMode(){
 	Q_D(CartesianPlot);
 	d->mouseReleaseZoomSelectionMode();
 }
 
 void CartesianPlot::mouseHoverZoomSelectionMode(QPointF logicPos){
 	Q_D(CartesianPlot);
 	d->mouseHoverZoomSelectionMode(logicPos);
 }
 
 //##############################################################################
 //######  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), q(plot) {
 	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() {
 	DEBUG("CartesianPlotPrivate::retransformScales()");
 	DEBUG(" xmin/xmax = " << xMin << '/'<< xMax << ", ymin/ymax = " << yMin << '/' << yMax);
 	PERFTRACE("CartesianPlotPrivate::retransformScales()");
 
 	auto* plot = dynamic_cast<CartesianPlot*>(q);
 	QVector<CartesianScale*> scales;
 
 	//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 = dataRect.x();
 	int plotSceneEnd = dataRect.x() + dataRect.width();
 	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) {
 			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 = dataRect.y() + dataRect.height();
 	plotSceneEnd = dataRect.y();
 	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) {
 			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>()) {
 		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);
 
 	double paddingLeft = horizontalPadding;
 	double paddingRight = rightPadding;
 	double paddingTop = verticalPadding;
 	double paddingBottom = bottomPadding;
 	if (symmetricPadding) {
 		paddingRight = horizontalPadding;
 		paddingBottom = verticalPadding;
 	}
 
 	dataRect.setX(dataRect.x() + paddingLeft);
 	dataRect.setY(dataRect.y() + paddingTop);
 
 	double newHeight = dataRect.height() - paddingBottom;
 	if (newHeight < 0)
 		newHeight = 0;
 	dataRect.setHeight(newHeight);
 
 	double newWidth = dataRect.width() - paddingRight;
 	if (newWidth < 0)
 		newWidth = 0;
 	dataRect.setWidth(newWidth);
 }
 
 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
 		return CartesianScale::createLogScale(interval, sceneStart, sceneEnd, logicalStart, logicalEnd, type);
 }
 
 /*!
  * 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) {
 		emit q->mousePressZoomSelectionModeSignal(cSystem->mapSceneToLogical(event->pos()));
 
 		if (mouseMode == CartesianPlot::ZoomSelectionMode)
 			m_selectionStart = event->pos();
 		else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 			m_selectionStart.setX(event->pos().x());
 			m_selectionStart.setY(dataRect.y());
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 			m_selectionStart.setX(dataRect.x());
 			m_selectionStart.setY(event->pos().y());
 		}
 
 		m_selectionEnd = m_selectionStart;
 		m_selectionBandIsShown = true;
 	} else if (mouseMode == CartesianPlot::Cursor){
 		QPointF logicalPos = cSystem->mapSceneToLogical(event->pos(), AbstractCoordinateSystem::MappingFlag::Limit);
 		double cursorPenWidth2 = cursorPen.width()/2;
 		if (cursorPenWidth2 < 10)
 			cursorPenWidth2 = 10;
 		if (cursor0Enable && qAbs(event->pos().x()-cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMin)).x()) < cursorPenWidth2) {
 			selectedCursor = 0;
 		} else if (cursor1Enable && qAbs(event->pos().x()-cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMin)).x()) < cursorPenWidth2) {
 			selectedCursor = 1;
 		} else if (QApplication::keyboardModifiers() & Qt::ControlModifier){
 			cursor1Enable = true;
 			selectedCursor = 1;
 			emit q->cursor1EnableChanged(cursor1Enable);
 		} else {
 			cursor0Enable = true;
 			selectedCursor = 0;
 			emit q->cursor0EnableChanged(cursor0Enable);
 		}
 		emit q->mousePressCursorModeSignal(selectedCursor, logicalPos);
 
 	} else {
 		if (!locked && dataRect.contains(event->pos()) ){
 			panningStarted = true;
 			m_panningStart = event->pos();
 			setCursor(Qt::ClosedHandCursor);
 		}
 		QGraphicsItem::mousePressEvent(event);
 	}
 }
 
 void CartesianPlotPrivate::mousePressZoomSelectionMode(QPointF logicalPos){
 	if (mouseMode == CartesianPlot::ZoomSelectionMode){
 
 		if (logicalPos.x() < xMin)
 			logicalPos.setX(xMin);
 
 		if (logicalPos.x() > xMax)
 			logicalPos.setX(xMax);
 
 		if (logicalPos.y() < yMin)
 			logicalPos.setY(yMin);
 
 		if (logicalPos.y() > yMax)
 			logicalPos.setY(yMax);
 
 		m_selectionStart = cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping);
 
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 		logicalPos.setY(yMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionStart.setX(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping).x());
 		m_selectionStart.setY(dataRect.height()/2);
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		logicalPos.setX(xMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionStart.setX(-dataRect.width()/2);
 		m_selectionStart.setY(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping).y());
 	}
 	m_selectionEnd = m_selectionStart;
 	m_selectionBandIsShown = true;
 }
 
 void CartesianPlotPrivate::mousePressCursorMode(int cursorNumber, QPointF logicalPos){
 
 	cursorNumber == 0 ? cursor0Enable = true : cursor1Enable = true;
 
 	QPointF p1(logicalPos.x(), yMin);
 	QPointF p2(logicalPos.x(), yMax);
 
 	if (cursorNumber == 0) {
 		cursor0Pos.setX(logicalPos.x());
 		cursor0Pos.setY(0);
 	} else {
 		cursor1Pos.setX(logicalPos.x());
 		cursor1Pos.setY(0);
 	}
 	update();
 }
 
 void CartesianPlotPrivate::updateCursor() {
 	update();
 }
 
 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(QString());
 			return;
 		}
 		emit q->mouseMoveZoomSelectionModeSignal(cSystem->mapSceneToLogical(event->pos(), CartesianCoordinateSystem::MappingFlag::Limit));
 
 	} else if (mouseMode == CartesianPlot::Cursor) {
 		QGraphicsItem::mouseMoveEvent(event);
 		if (!boundingRect().contains(event->pos())) {
 			q->info(i18n("Not inside of the bounding rect"));
 			return;
 		}
 		QPointF logicalPos = cSystem->mapSceneToLogical(event->pos(), AbstractCoordinateSystem::MappingFlag::Limit);
 
 		// updating treeview data and cursor position
 		// updatign cursor position is done in Worksheet, because
 		// multiple plots must be updated
 		emit q->mouseMoveCursorModeSignal(selectedCursor, logicalPos);
 	}
 }
 
 void CartesianPlotPrivate::mouseMoveZoomSelectionMode(QPointF logicalPos) {
 	QString info;
 	QPointF logicalStart = cSystem->mapSceneToLogical(m_selectionStart, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 	if (mouseMode == CartesianPlot::ZoomSelectionMode) {
 		m_selectionEnd = cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 		QPointF logicalEnd = logicalPos;
 		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) {
 		logicalPos.setY(yMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionEnd.setX(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping).x());//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);
 		logicalPos.setX(xMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionEnd.setY(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping).y());//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::mouseMoveCursorMode(int cursorNumber, QPointF logicalPos){
 
 	QPointF p1(logicalPos.x(), 0);
 	cursorNumber == 0 ? cursor0Pos = p1 : cursor1Pos = p1;
 
 	QString info;
 	if (xRangeFormat == CartesianPlot::Numeric)
 		info = QString::fromUtf8("x=") + QString::number(logicalPos.x());
 	else
 		info = i18n("x=%1", QDateTime::fromMSecsSinceEpoch(logicalPos.x()).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) {
 		emit q->mouseReleaseZoomSelectionModeSignal();
 	}
 }
 
 void CartesianPlotPrivate::mouseReleaseZoomSelectionMode(){
 	//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) {
 	if (locked)
 		return;
 
 	//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>()) {
 		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);
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
 		} else if (mouseMode == CartesianPlot::ZoomXSelectionMode && !m_selectionBandIsShown) {
 			info = "x=";
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode && !m_selectionBandIsShown) {	
 			info = "y=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.y());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.y()).toString(yRangeDateTimeFormat);
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
         } else if (mouseMode == CartesianPlot::MouseMode::SelectionMode) {
 			// hover the nearest curve to the mousepointer
 			// hovering curves is implemented in the parent, because no ignoreEvent() exists
 			// for it. Checking all curves and hover the first
 			bool curve_hovered = false;
 			QVector<XYCurve*> curves = q->children<XYCurve>();
 			for (int i=curves.count() - 1; i >= 0; i--){ // because the last curve is above the other curves
 				if (curve_hovered){ // if a curve is already hovered, disable hover for the rest
 					curves[i]->setHover(false);
 					continue;
 				}
 				if (curves[i]->activateCurve(event->pos())){
 					curves[i]->setHover(true);
 					curve_hovered = true;
 					continue;
 				}
 				curves[i]->setHover(false);
 			}
 		} else if (mouseMode == CartesianPlot::Cursor){
 			info = "x=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 
 			double cursorPenWidth2 = cursorPen.width()/2;
 			if (cursorPenWidth2 < 10)
 				cursorPenWidth2 = 10;
 			if ((cursor0Enable && qAbs(point.x()-cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMin)).x()) < cursorPenWidth2) ||
 					(cursor1Enable && qAbs(point.x()-cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMin)).x()) < cursorPenWidth2))
 				setCursor(Qt::SizeHorCursor);
 			else
 				setCursor(Qt::ArrowCursor);
 
 			update();
 		}
 	}
 	q->info(info);
 
 	QGraphicsItem::hoverMoveEvent(event);
 }
 
 void CartesianPlotPrivate::mouseHoverZoomSelectionMode(QPointF logicPos) {
 	if (mouseMode == CartesianPlot::ZoomSelectionMode && !m_selectionBandIsShown) {
 
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode && !m_selectionBandIsShown) {
 		QPointF p1(logicPos.x(), yMin);
 		QPointF p2(logicPos.x(), yMax);
 		m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1, CartesianCoordinateSystem::MappingFlag::Limit));
 		m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2, CartesianCoordinateSystem::MappingFlag::Limit));
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode && !m_selectionBandIsShown) {
 		QPointF p1(xMin, logicPos.y());
 		QPointF p2(xMax, logicPos.y());
 		m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1, CartesianCoordinateSystem::MappingFlag::Limit));
 		m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2, CartesianCoordinateSystem::MappingFlag::Limit));
 	}
 
 	update(); // because if previous another selection mode was selected, the lines must be deleted
 }
 
 void CartesianPlotPrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	if (!isVisible())
 		return;
 
 	if (!m_printing) {
 		painter->save();
 
 		painter->setPen(cursorPen);
 		QFont font = painter->font();
 		font.setPointSize(font.pointSize() * 4);
 		painter->setFont(font);
 
 		if (cursor0Enable && cSystem->mapLogicalToScene(cursor0Pos, AbstractCoordinateSystem::MappingFlag::SuppressPageClippingY) != QPointF(0,0)){
 			QPointF p1(cursor0Pos.x(),yMin);
 			p1 = cSystem->mapLogicalToScene(p1);
 			QPointF p2(cursor0Pos.x(),yMax);
 			p2 = cSystem->mapLogicalToScene(p2);
 			painter->drawLine(p1,p2);
 			painter->drawText(p2, "1");
 		}
 
 		if (cursor1Enable && cSystem->mapLogicalToScene(cursor0Pos, AbstractCoordinateSystem::MappingFlag::SuppressPageClippingY) != QPointF(0,0)){
 			QPointF p1(cursor1Pos.x(),yMin);
 			p1 = cSystem->mapLogicalToScene(p1);
 			QPointF p2(cursor1Pos.x(),yMax);
 			p2 = cSystem->mapLogicalToScene(p2);
 			painter->drawText(p2, "2");
 			painter->drawLine(p1,p2);
 		}
 
 		painter->restore();
 	}
 
 	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();
 	}
 
 	float penWidth = 6.;
 	QRectF rect = q->m_plotArea->graphicsItem()->boundingRect();
 	rect = QRectF(-rect.width()/2 - penWidth / 2, -rect.height()/2 - penWidth / 2,
 				  rect.width() + penWidth, rect.height() + penWidth);
 
 	if (m_hovered && !isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Shadow), penWidth, Qt::SolidLine));
 		painter->drawRect(rect);
 	}
 
 	if (isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Highlight), penWidth, Qt::SolidLine));
 		painter->drawRect(rect);
 	}
 }
 
 //##############################################################################
 //##################  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();
 	}
 
     //cursor
     writer->writeStartElement( "cursor" );
 	WRITE_QPEN(d->cursorPen);
     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, 'g', 16));
 	writer->writeAttribute( "xMax", QString::number(d->xMax, 'g', 16) );
 	writer->writeAttribute( "yMin", QString::number(d->yMin, 'g', 16) );
 	writer->writeAttribute( "yMax", QString::number(d->yMax, 'g', 16) );
 	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->writeAttribute( "rightPadding", QString::number(d->rightPadding) );
 	writer->writeAttribute( "bottomPadding", QString::number(d->bottomPadding) );
 	writer->writeAttribute( "symmetricPadding", QString::number(d->symmetricPadding));
 	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) {
 			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) {
 			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))
 		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() == "cursor") {
             attribs = reader->attributes();
             QPen pen;
             pen.setWidth(attribs.value("width").toInt());
             pen.setStyle(static_cast<Qt::PenStyle>(attribs.value("style").toInt()));
             QColor color;
             color.setRed(attribs.value("color_r").toInt());
             color.setGreen(attribs.value("color_g").toInt());
             color.setBlue(attribs.value("color_b").toInt());
             pen.setColor(color);
             d->cursorPen = pen;
         } 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);
 			READ_DOUBLE_VALUE("rightPadding", rightPadding);
 			READ_DOUBLE_VALUE("bottomPadding", bottomPadding);
 			READ_INT_VALUE("symmetricPadding", symmetricPadding, bool);
 		} 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;
 
 				//TODO: the name is read in m_title->load() but we overwrite it here
 				//since the old projects don't have this " - Title" appendix yet that we add in init().
 				//can be removed in couple of releases
 				m_title->setName(name() + QLatin1String(" - ") + i18n("Title"));
 			} 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(QString());
 			if (axis->load(reader, preview))
 				addChildFast(axis);
 			else {
 				delete axis;
 				return false;
 			}
 		} else if (reader->name() == "xyCurve") {
 			XYCurve* curve = new XYCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyEquationCurve") {
 			XYEquationCurve* curve = new XYEquationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDataReductionCurve") {
 			XYDataReductionCurve* curve = new XYDataReductionCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDifferentiationCurve") {
 			XYDifferentiationCurve* curve = new XYDifferentiationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyIntegrationCurve") {
 			XYIntegrationCurve* curve = new XYIntegrationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyInterpolationCurve") {
 			XYInterpolationCurve* curve = new XYInterpolationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xySmoothCurve") {
 			XYSmoothCurve* curve = new XYSmoothCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFitCurve") {
 			XYFitCurve* curve = new XYFitCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierFilterCurve") {
 			XYFourierFilterCurve* curve = new XYFourierFilterCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierTransformCurve") {
 			XYFourierTransformCurve* curve = new XYFourierTransformCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyConvolutionCurve") {
 			XYConvolutionCurve* curve = new XYConvolutionCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyCorrelationCurve") {
 			XYCorrelationCurve* curve = new XYCorrelationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "cartesianPlotLegend") {
 			m_legend = new CartesianPlotLegend(this, QString());
 			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, QString());
 			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();
 
 	// theme path is saved with UNIX dir separator
 	str = str.right(str.length() - str.lastIndexOf(QLatin1Char('/')) - 1);
 	DEBUG("	set theme to " << str.toStdString());
 	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))
 		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))
 		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/CartesianPlot.h b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
index 4fecee569..a2dab6605 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.h
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
@@ -1,321 +1,322 @@
 
 /***************************************************************************
     File                 : CartesianPlot.h
     Project              : LabPlot
     Description          : Cartesian plot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
     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                                           *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef CARTESIANPLOT_H
 #define CARTESIANPLOT_H
 
 #include "backend/worksheet/plots/AbstractPlot.h"
 #include "backend/worksheet/plots/cartesian/Histogram.h"
 
 #include <cmath>
 
 class QDropEvent;
 class QToolBar;
 class CartesianPlotPrivate;
 class CartesianPlotLegend;
 class AbstractColumn;
 class XYCurve;
 class XYEquationCurve;
 class XYDataReductionCurve;
 class XYDifferentiationCurve;
 class XYIntegrationCurve;
 class XYInterpolationCurve;
 class XYSmoothCurve;
 class XYFitCurve;
 class XYFourierFilterCurve;
 class XYFourierTransformCurve;
 class XYConvolutionCurve;
 class XYCorrelationCurve;
 class KConfig;
 
 class CartesianPlot : public AbstractPlot {
 	Q_OBJECT
 
 public:
 	explicit CartesianPlot(const QString &name);
 	~CartesianPlot() override;
 
 	enum Scale {ScaleLinear, ScaleLog10, ScaleLog2, ScaleLn, ScaleLog10Abs, ScaleLog2Abs, ScaleLnAbs, ScaleSqrt, ScaleX2};
 	enum Type {FourAxes, TwoAxes, TwoAxesCentered, TwoAxesCenteredZero};
 	enum RangeFormat {Numeric, DateTime};
 	enum RangeType {RangeFree, RangeLast, RangeFirst};
 	enum RangeBreakStyle {RangeBreakSimple, RangeBreakVertical, RangeBreakSloped};
 	enum MouseMode {SelectionMode, ZoomSelectionMode, ZoomXSelectionMode, ZoomYSelectionMode, Cursor};
 	enum NavigationOperation {ScaleAuto, ScaleAutoX, ScaleAutoY, ZoomIn, ZoomOut, ZoomInX, ZoomOutX,
 	                          ZoomInY, ZoomOutY, ShiftLeftX, ShiftRightX, ShiftUpY, ShiftDownY
 	                         };
 
 	struct RangeBreak {
 		RangeBreak() : start(NAN), end(NAN), position(0.5), style(RangeBreakSloped) {}
 		bool isValid() const {
 			return (!std::isnan(start) && !std::isnan(end));
 		}
 		double start;
 		double end;
 		double position;
 		RangeBreakStyle style;
 	};
 
 	//simple wrapper for QList<RangeBreaking> in order to get our macros working
 	struct RangeBreaks {
 		RangeBreaks() : lastChanged(-1) {
 			RangeBreak b;
 			list << b;
 		};
 		QList<RangeBreak> list;
 		int lastChanged;
 	};
 
 	void initDefault(Type = FourAxes);
 	QIcon icon() const override;
 	QMenu* createContextMenu() override;
 	QMenu* analysisMenu();
 	QVector<AbstractAspect*> dependsOn() const override;
 	void setRect(const QRectF&) override;
 	QRectF dataRect() const;
 	void setMouseMode(const MouseMode);
 	void setLocked(const bool);
 	MouseMode mouseMode() const;
 	void navigate(NavigationOperation);
 	void setSuppressDataChangedSignal(bool);
 	const QList<QColor>& themeColorPalette() const;
 	void processDropEvent(QDropEvent*) override;
 	bool isPanningActive() const;
 	void addLegend(CartesianPlotLegend*);
 	int curveCount();
 	const XYCurve* getCurve(int index);
 	double cursorPos(int cursorNumber);
 
 	void save(QXmlStreamWriter*) const override;
 	bool load(XmlStreamReader*, bool preview) override;
 	void loadThemeConfig(const KConfig&) override;
 	void saveTheme(KConfig& config);
 	void mousePressZoomSelectionMode(QPointF logicPos);
 	void mousePressCursorMode(int cursorNumber, QPointF logicPos);
 	void mouseMoveZoomSelectionMode(QPointF logicPos);
 	void mouseMoveCursorMode(int cursorNumber, QPointF logicPos);
 	void mouseReleaseZoomSelectionMode();
         void mouseHoverZoomSelectionMode(QPointF logicPos);
 
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeFormat, xRangeFormat, XRangeFormat)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeFormat, yRangeFormat, YRangeFormat)
 	const QString& xRangeDateTimeFormat() const;
 	const QString& yRangeDateTimeFormat() const;
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeType, rangeType, RangeType)
 	BASIC_D_ACCESSOR_DECL(int, rangeLastValues, RangeLastValues)
 	BASIC_D_ACCESSOR_DECL(int, rangeFirstValues, RangeFirstValues)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleX, AutoScaleX)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleY, AutoScaleY)
 	BASIC_D_ACCESSOR_DECL(double, xMin, XMin)
 	BASIC_D_ACCESSOR_DECL(double, xMax, XMax)
 	BASIC_D_ACCESSOR_DECL(double, yMin, YMin)
 	BASIC_D_ACCESSOR_DECL(double, yMax, YMax)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, xScale, XScale)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, yScale, YScale)
 	BASIC_D_ACCESSOR_DECL(bool, xRangeBreakingEnabled, XRangeBreakingEnabled)
 	BASIC_D_ACCESSOR_DECL(bool, yRangeBreakingEnabled, YRangeBreakingEnabled)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, xRangeBreaks, XRangeBreaks)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, yRangeBreaks, YRangeBreaks)
 	CLASS_D_ACCESSOR_DECL(QPen, cursorPen, CursorPen);
 	CLASS_D_ACCESSOR_DECL(bool, cursor0Enable, Cursor0Enable);
 	CLASS_D_ACCESSOR_DECL(bool, cursor1Enable, Cursor1Enable);
 
 	QString theme() const;
 
 	typedef CartesianPlotPrivate Private;
 
 public slots:
 	void setTheme(const QString&);
 
 private:
 	void init();
 	void initActions();
 	void initMenus();
 	void setColorPalette(const KConfig&);
 	const XYCurve* currentCurve() const;
 
 	CartesianPlotLegend* m_legend{nullptr};
 	double m_zoomFactor{1.2};
 	QList<QColor> m_themeColorPalette;
 	bool m_menusInitialized{false};
 
 	QAction* visibilityAction;
 
 	//"add new" actions
 	QAction* addCurveAction;
 	QAction* addEquationCurveAction;
 	QAction* addHistogramAction;
 	QAction* addDataReductionCurveAction;
 	QAction* addDifferentiationCurveAction;
 	QAction* addIntegrationCurveAction;
 	QAction* addInterpolationCurveAction;
 	QAction* addSmoothCurveAction;
 	QAction* addFitCurveAction;
 	QAction* addFourierFilterCurveAction;
 	QAction* addFourierTransformCurveAction;
 	QAction* addConvolutionCurveAction;
 	QAction* addCorrelationCurveAction;
 
 	QAction* addHorizontalAxisAction;
 	QAction* addVerticalAxisAction;
 	QAction* addLegendAction;
 	QAction* addTextLabelAction;
 	QAction* addCustomPointAction;
 
 	//scaling, zooming, navigation actions
 	QAction* scaleAutoXAction;
 	QAction* scaleAutoYAction;
 	QAction* scaleAutoAction;
 	QAction* zoomInAction;
 	QAction* zoomOutAction;
 	QAction* zoomInXAction;
 	QAction* zoomOutXAction;
 	QAction* zoomInYAction;
 	QAction* zoomOutYAction;
 	QAction* shiftLeftXAction;
 	QAction* shiftRightXAction;
 	QAction* shiftUpYAction;
 	QAction* shiftDownYAction;
 	QAction* cursorAction;
 
 	//analysis menu actions
 	QAction* addDataOperationAction;
 	QAction* addDataReductionAction;
 	QAction* addDifferentiationAction;
 	QAction* addIntegrationAction;
 	QAction* addInterpolationAction;
 	QAction* addSmoothAction;
 	QVector <QAction *> addFitAction;
 	QAction* addFourierFilterAction;
 	QAction* addConvolutionAction;
 	QAction* addCorrelationAction;
 
 	QMenu* addNewMenu{nullptr};
 	QMenu* zoomMenu{nullptr};
 	QMenu* dataAnalysisMenu{nullptr};
 	QMenu* themeMenu{nullptr};
 
 	Q_DECLARE_PRIVATE(CartesianPlot)
 
 public slots:
 	void addHorizontalAxis();
 	void addVerticalAxis();
 	void addCurve();
 	void addHistogram();
 	void addEquationCurve();
 	void addDataReductionCurve();
 	void addDifferentiationCurve();
 	void addIntegrationCurve();
 	void addInterpolationCurve();
 	void addSmoothCurve();
 	void addFitCurve();
 	void addFourierFilterCurve();
 	void addFourierTransformCurve();
 	void addConvolutionCurve();
 	void addCorrelationCurve();
 
 	void addLegend();
 	void addTextLabel();
 	void addCustomPoint();
 	bool scaleAuto();
 	bool scaleAutoX();
 	bool scaleAutoY();
 	void zoomIn();
 	void zoomOut();
 	void zoomInX();
 	void zoomOutX();
 	void zoomInY();
 	void zoomOutY();
 	void shiftLeftX();
 	void shiftRightX();
 	void shiftUpY();
 	void shiftDownY();
 	void cursor();
 	void dataChanged();
 
+	void curveLinePenChanged(QPen);
+
 private slots:
 	void updateLegend();
 	void childAdded(const AbstractAspect*);
 	void childRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child);
 	void childHovered();
 
 	void xDataChanged();
 	void yDataChanged();
 	void curveVisibilityChanged();
 
-	void curveLinePenChanged(QPen);
 
 	//SLOTs for changes triggered via QActions in the context menu
 	void visibilityChanged();
 	void loadTheme(const QString&);
 
 protected:
 	CartesianPlot(const QString &name, CartesianPlotPrivate *dd);
 
 signals:
 	void rangeTypeChanged(CartesianPlot::RangeType);
 	void xRangeFormatChanged(CartesianPlot::RangeFormat);
 	void yRangeFormatChanged(CartesianPlot::RangeFormat);
 	void rangeLastValuesChanged(int);
 	void rangeFirstValuesChanged(int);
 	void rectChanged(QRectF&);
 	void xAutoScaleChanged(bool);
 	void xMinChanged(double);
 	void xMaxChanged(double);
 	void xScaleChanged(int);
 	void yAutoScaleChanged(bool);
 	void yMinChanged(double);
 	void yMaxChanged(double);
 	void yScaleChanged(int);
 	void xRangeBreakingEnabledChanged(bool);
 	void xRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void yRangeBreakingEnabledChanged(bool);
 	void yRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void themeChanged(const QString&);
 	void mousePressZoomSelectionModeSignal(QPointF logicPos);
 	void mousePressCursorModeSignal(int cursorNumber, QPointF logicPos);
 	void mouseMoveZoomSelectionModeSignal(QPointF logicPos);
 	void mouseMoveCursorModeSignal(int cursorNumber, QPointF logicPos);
 	void mouseReleaseCursorModeSignal();
 	void mouseReleaseZoomSelectionModeSignal();
         void mouseHoverZoomSelectionModeSignal(QPointF logicalPoint);
 	void cursorPosChanged(int cursorNumber, double xPos);
 	void curveAdded(const XYCurve*);
 	void curveRemoved(const XYCurve*);
 	void curveLinePenChanged(QPen, QString curveName);
 	void cursorPenChanged(QPen);
 	void curveDataChanged(const XYCurve*);
 	void curveVisibilityChangedSignal();
 	void mouseModeChanged();
 	void cursor0EnableChanged(bool enable);
 	void cursor1EnableChanged(bool enable);
 };
 
 #endif
diff --git a/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp b/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
index 5d6b7927d..d093eb96b 100644
--- a/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
+++ b/src/kdefrontend/dockwidgets/CartesianPlotDock.cpp
@@ -1,1757 +1,1757 @@
 /***************************************************************************
     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) : BaseDock(parent) {
 	ui.setupUi(this);
 	m_leName = ui.leName;
 	m_leComment = ui.leComment;
 
 	//"General"-tab
 	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") );
 
 	ui.leBackgroundFileName->setCompleter(new QCompleter(new QDirModel, this));
 
 	//"Title"-tab
 	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());
 		if (!layout)
 			continue;
 
 		layout->setContentsMargins(2,2,2,2);
 		layout->setHorizontalSpacing(2);
 		layout->setVerticalSpacing(2);
 	}
 
 	// "Cursor"-tab
 	QStringList list = {i18n("NoPen"), i18n("SolidLine"), i18n("DashLine"), i18n("DotLine"), i18n("DashDotLine"), i18n("DashDotDotLine")};
 	ui.cbCursorLineStyle->clear();
 	for (int i = 0; i < list.count(); i++)
 		ui.cbCursorLineStyle->addItem(list[i], i);
 
 	//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)) );
-	connect( ui.sbPaddingRight, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &CartesianPlotDock::rightPaddingChanged);
-	connect( ui.sbPaddingBottom, QOverload<double>::of(&QDoubleSpinBox::valueChanged), this, &CartesianPlotDock::bottomPaddingChanged);
+	connect( ui.sbPaddingRight, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &CartesianPlotDock::rightPaddingChanged);
+	connect( ui.sbPaddingBottom, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &CartesianPlotDock::bottomPaddingChanged);
 	connect( ui.cbPaddingSymmetric, &QCheckBox::toggled, this, &CartesianPlotDock::symmetricPaddingChanged);
 
 	// Cursor
 	connect(ui.sbCursorLineWidth, SIGNAL(valueChanged(int)), this, SLOT(cursorLineWidthChanged(int)));
 	//connect(ui.sbCursorLineWidth, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &CartesianPlotDock::cursorLineWidthChanged);
 	connect(ui.kcbCursorLineColor, &KColorButton::changed, this, &CartesianPlotDock::cursorLineColorChanged);
 	//connect(ui.cbCursorLineStyle, qOverload<int>(&QComboBox::currentIndexChanged), this, &CartesianPlotDock::cursorLineStyleChanged);
 	connect(ui.cbCursorLineStyle, SIGNAL(currentIndexChanged(int)), this, SLOT(cursorLineStyleChanged(int)));
 	//theme and template handlers
 	auto* frame = new QFrame(this);
 	auto* layout = new QHBoxLayout(frame);
 	layout->setContentsMargins(0, 11, 0, 11);
 
 	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);
 	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();
 	m_aspect = list.first();
 
 	QList<TextLabel*> labels;
 	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(QString());
 		ui.leComment->setText(QString());
 	}
 
 	bool symmectric = m_plot->symmetricPadding();
 	ui.lPaddingHorizontalRight->setVisible(!symmectric);
 	ui.sbPaddingRight->setVisible(!symmectric);
 	ui.lPaddingVerticalDown->setVisible(!symmectric);
 	ui.sbPaddingBottom->setVisible(!symmectric);
 	if (symmectric) {
 		ui.lPaddingHorizontal->setText(i18n("Horizontal"));
 		ui.lPaddingVertical->setText(i18n("Vertical"));
 	} else {
 		ui.lPaddingHorizontal->setText(i18n("Left"));
 		ui.lPaddingVertical->setText(i18n("Top"));
 	}
 
 	ui.leName->setStyleSheet("");
 	ui.leName->setToolTip("");
 
 	//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());
 	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)) );
 	connect(m_plot, &CartesianPlot::rightPaddingChanged, this, &CartesianPlotDock::plotRightPaddingChanged);
 	connect(m_plot, &CartesianPlot::bottomPaddingChanged, this, &CartesianPlotDock::plotBottomPaddingChanged);
 	connect(m_plot, &CartesianPlot::symmetricPaddingChanged, this, &CartesianPlotDock::plotSymmetricPaddingChanged);
 
 	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.cbXScaling->addItem( i18n("log(abs(x))") );
 	ui.cbXScaling->addItem( i18n("log2(abs(x))") );
 	ui.cbXScaling->addItem( i18n("ln(abs(x))") );
 
 	ui.cbYScaling->addItem( i18n("linear") );
 	ui.cbYScaling->addItem( i18n("log(y)") );
 	ui.cbYScaling->addItem( i18n("log2(y)") );
 	ui.cbYScaling->addItem( i18n("ln(y)") );
 	ui.cbYScaling->addItem( i18n("log(abs(y))") );
 	ui.cbYScaling->addItem( i18n("log2(abs(y))") );
 	ui.cbYScaling->addItem( i18n("ln(abs(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::visibilityChanged(bool state) {
 	if (m_initializing)
 		return;
 
 	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)
 		plot->setRangeType(type);
 }
 
 void CartesianPlotDock::rangeFirstChanged(const QString& text) {
 	if (m_initializing)
 		return;
 
 	const int value = text.toInt();
 	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)
 		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)
 		plot->setAutoScaleX(checked);
 }
 
 void CartesianPlotDock::xMinChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float min = value.toDouble();
 	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)
 		plot->setXMax(max);
 }
 
 void CartesianPlotDock::xMinDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
 	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)
 		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)
 		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)
 		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)
 		plot->setAutoScaleY(checked);
 }
 
 void CartesianPlotDock::yMinChanged(const QString& value) {
 	if (m_initializing)
 		return;
 
 	const float min = value.toDouble();
 	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)
 		plot->setYMax(max);
 }
 
 void CartesianPlotDock::yMinDateTimeChanged(const QDateTime& dateTime) {
 	if (m_initializing)
 		return;
 
 	quint64 value = dateTime.toMSecsSinceEpoch();
 	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)
 		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)
 		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)
 		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)
 		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)
 		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)
 		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() : QString::number(rangeBreak.start);
 	ui.leXBreakStart->setText(str);
 	str = std::isnan(rangeBreak.end) ? QString() : 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)
 		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)
 		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)
 		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)
 		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)
 		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)
 		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)
 		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() : QString::number(rangeBreak.start);
 	ui.leYBreakStart->setText(str);
 	str = std::isnan(rangeBreak.end) ? QString() : 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)
 		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)
 		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)
 		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)
 		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)
 		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)
 		plot->plotArea()->setBackgroundColorStyle(style);
 }
 
 void CartesianPlotDock::backgroundImageStyleChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto style = (PlotArea::BackgroundImageStyle)index;
 	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)
 		plot->plotArea()->setBackgroundBrushStyle(style);
 }
 
 void CartesianPlotDock::backgroundFirstColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
 	for (auto* plot : m_plotList)
 		plot->plotArea()->setBackgroundFirstColor(c);
 }
 
 void CartesianPlotDock::backgroundSecondColorChanged(const QColor& c) {
 	if (m_initializing)
 		return;
 
 	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()) {
 		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)
 		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(QString());
 
 	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)
 		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) {
 		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) {
 		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) {
 		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)
 		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)
 		plot->plotArea()->setBorderOpacity(opacity);
 }
 
 void CartesianPlotDock::symmetricPaddingChanged(bool checked) {
 	if (m_initializing)
 		return;
 
 	ui.lPaddingHorizontalRight->setVisible(!checked);
 	ui.sbPaddingRight->setVisible(!checked);
 	ui.lPaddingVerticalDown->setVisible(!checked);
 	ui.sbPaddingBottom->setVisible(!checked);
 
 	if (checked) {
 		ui.lPaddingHorizontal->setText(i18n("Horizontal"));
 		ui.lPaddingVertical->setText(i18n("Vertical"));
 	} else {
 		ui.lPaddingHorizontal->setText(i18n("Left"));
 		ui.lPaddingVertical->setText(i18n("Top"));
 	}
 
 	for (auto* plot : m_plotList)
 		plot->setSymmetricPadding(checked);
 
 	if (checked) {
 		rightPaddingChanged(ui.sbPaddingHorizontal->value());
 		bottomPaddingChanged(ui.sbPaddingVertical->value());
 	}
 }
 
 void CartesianPlotDock::horizontalPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 	double padding = Worksheet::convertToSceneUnits(value, Worksheet::Centimeter);
 	for (auto* plot : m_plotList)
 			plot->setHorizontalPadding(padding);
 
 	if (m_plot->symmetricPadding()) {
 		for (auto* plot: m_plotList)
 			plot->setRightPadding(padding);
 	}
 }
 
 void CartesianPlotDock::rightPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 	double padding = Worksheet::convertToSceneUnits(value, Worksheet::Centimeter);
 	for (auto* plot : m_plotList)
 		plot->setRightPadding(padding);
 }
 
 void CartesianPlotDock::verticalPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 
 	// TODO: find better solution (set spinbox range). When plot->rect().width() does change?
 	double padding = Worksheet::convertToSceneUnits(value, Worksheet::Centimeter);
 	for (auto* plot : m_plotList)
 		plot->setVerticalPadding(padding);
 
 	if (m_plot->symmetricPadding()) {
 		for (auto* plot: m_plotList)
 			plot->setBottomPadding(padding);
 	}
 }
 
 void CartesianPlotDock::bottomPaddingChanged(double value) {
 	if (m_initializing)
 		return;
 	double padding = Worksheet::convertToSceneUnits(value, Worksheet::Centimeter);
 	for (auto* plot : m_plotList)
 		plot->setBottomPadding(padding);
 }
 
 void CartesianPlotDock::cursorLineWidthChanged(int width) {
     if (m_initializing)
         return;
 
     for (auto* plot : m_plotList) {
         QPen pen = plot->cursorPen();
         pen.setWidth(width);
         plot->setCursorPen(pen);
     }
 }
 
 void CartesianPlotDock::cursorLineColorChanged(QColor color) {
     if (m_initializing)
         return;
 
     for (auto* plot : m_plotList) {
         QPen pen = plot->cursorPen();
         pen.setColor(color);
         plot->setCursorPen(pen);
     }
 }
 
 void CartesianPlotDock::cursorLineStyleChanged(int index) {
     if (m_initializing)
         return;
 
     if (index > 5)
         return;
 
     for (auto* plot : m_plotList) {
         QPen pen = plot->cursorPen();
         pen.setStyle(static_cast<Qt::PenStyle>(index));
         plot->setCursorPen(pen);
     }
 }
 
 //*************************************************************
 //****** 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;
 }
 
 void CartesianPlotDock::plotRightPaddingChanged(double value) {
 	m_initializing = true;
 	ui.sbPaddingRight->setValue(Worksheet::convertFromSceneUnits(value, Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotBottomPaddingChanged(double value) {
 	m_initializing = true;
 	ui.sbPaddingBottom->setValue(Worksheet::convertFromSceneUnits(value, Worksheet::Centimeter));
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotSymmetricPaddingChanged(bool symmetric) {
 	m_initializing = true;
 	ui.cbPaddingSymmetric->setChecked(symmetric);
 	m_initializing = false;
 }
 
 void CartesianPlotDock::plotCursorPenChanged(QPen pen) {
     m_initializing = true;
     ui.sbCursorLineWidth->setValue(pen.width());
     ui.kcbCursorLineColor->setColor(pen.color());
     ui.cbCursorLineStyle->setCurrentIndex(pen.style());
     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(QString());
 
 	//Padding
 	ui.sbPaddingHorizontal->setValue( Worksheet::convertFromSceneUnits(m_plot->horizontalPadding(), Worksheet::Centimeter) );
 	ui.sbPaddingVertical->setValue( Worksheet::convertFromSceneUnits(m_plot->verticalPadding(), Worksheet::Centimeter) );
 	ui.sbPaddingRight->setValue(Worksheet::convertFromSceneUnits(m_plot->rightPadding(), Worksheet::Centimeter));
 	ui.sbPaddingBottom->setValue(Worksheet::convertFromSceneUnits(m_plot->bottomPadding(), Worksheet::Centimeter));
 	ui.cbPaddingSymmetric->setChecked(m_plot->symmetricPadding());
 
 	//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());
 
 	// Cursor
 	QPen pen = m_plot->cursorPen();
 	ui.cbCursorLineStyle->setCurrentIndex(pen.style());
 	ui.kcbCursorLineColor->setColor(pen.color());
 	ui.sbCursorLineWidth->setValue(pen.width());
 }
 
 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));
 	ui.sbPaddingRight->setValue(Worksheet::convertFromSceneUnits(group.readEntry("RightPadding", m_plot->rightPadding()), Worksheet::Centimeter));
 	ui.sbPaddingBottom->setValue(Worksheet::convertFromSceneUnits(group.readEntry("BottomPadding", m_plot->bottomPadding()), Worksheet::Centimeter));
 	ui.cbPaddingSymmetric->setChecked(group.readEntry("SymmetricPadding", m_plot->symmetricPadding()));
 
 	//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));
 	group.writeEntry("RightPadding", Worksheet::convertToSceneUnits(ui.sbPaddingRight->value(), Worksheet::Centimeter));
 	group.writeEntry("BottomPadding", Worksheet::convertToSceneUnits(ui.sbPaddingBottom->value(), Worksheet::Centimeter));
 	group.writeEntry("SymmetricPadding", ui.cbPaddingSymmetric->isChecked());
 
 	//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)
 		plot->setTheme(theme);
 }
 
 void CartesianPlotDock::saveTheme(KConfig& config) const {
 	if (!m_plotList.isEmpty())
 		m_plotList.at(0)->saveTheme(config);
 }