diff --git a/src/backend/worksheet/plots/cartesian/Axis.cpp b/src/backend/worksheet/plots/cartesian/Axis.cpp
index 361836c12..4ac7174a4 100644
--- a/src/backend/worksheet/plots/cartesian/Axis.cpp
+++ b/src/backend/worksheet/plots/cartesian/Axis.cpp
@@ -1,2355 +1,2360 @@
 /***************************************************************************
     File                 : Axis.cpp
     Project              : LabPlot
     Description          : Axis for cartesian coordinate systems.
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2013-2020 Stefan Gerlach  (stefan.gerlach@uni.kn)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/AxisPrivate.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/worksheet/plots/cartesian/CartesianCoordinateSystem.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/core/AbstractColumn.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/macros.h"
 // #include "backend/lib/trace.h"
 #include "kdefrontend/GuiTools.h"
 
 #include <QGraphicsSceneContextMenuEvent>
 #include <QMenu>
 #include <QPainter>
 #include <QTextDocument>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 extern "C" {
 #include <gsl/gsl_math.h>
 #include "backend/nsl/nsl_math.h"
 }
 
 /**
  * \class AxisGrid
  * \brief Helper class to get the axis grid drawn with the z-Value=0.
  *
  * The painting of the grid lines is separated from the painting of the axis itself.
  * This allows to use a different z-values for the grid lines (z=0, drawn below all other objects )
  * and for the axis (z=FLT_MAX, drawn on top of all other objects)
  *
  *  \ingroup worksheet
  */
 class AxisGrid : public QGraphicsItem {
 public:
 	explicit AxisGrid(AxisPrivate* a) {
 		axis = a;
 		setFlag(QGraphicsItem::ItemIsSelectable, false);
 		setFlag(QGraphicsItem::ItemIsFocusable, false);
 		setAcceptHoverEvents(false);
 	}
 
 	QRectF boundingRect() const override {
 		QPainterPath gridShape;
 		gridShape.addPath(WorksheetElement::shapeFromPath(axis->majorGridPath, axis->majorGridPen));
 		gridShape.addPath(WorksheetElement::shapeFromPath(axis->minorGridPath, axis->minorGridPen));
 		QRectF boundingRectangle = gridShape.boundingRect();
 		return boundingRectangle;
 	}
 
 	void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) override {
 		Q_UNUSED(option)
 		Q_UNUSED(widget)
 
 		if (!axis->isVisible()) return;
 		if (axis->linePath.isEmpty()) return;
 
 		//draw major grid
 		if (axis->majorGridPen.style() != Qt::NoPen) {
 			painter->setOpacity(axis->majorGridOpacity);
 			painter->setPen(axis->majorGridPen);
 			painter->setBrush(Qt::NoBrush);
 			painter->drawPath(axis->majorGridPath);
 		}
 
 		//draw minor grid
 		if (axis->minorGridPen.style() != Qt::NoPen) {
 			painter->setOpacity(axis->minorGridOpacity);
 			painter->setPen(axis->minorGridPen);
 			painter->setBrush(Qt::NoBrush);
 			painter->drawPath(axis->minorGridPath);
 		}
 	}
 
 private:
 	AxisPrivate* axis;
 };
 
 /**
  * \class Axis
  * \brief Axis for cartesian coordinate systems.
  *
  *  \ingroup worksheet
  */
 Axis::Axis(const QString& name, AxisOrientation orientation)
 		: WorksheetElement(name, AspectType::Axis), d_ptr(new AxisPrivate(this)) {
 	d_ptr->orientation = orientation;
 	init();
 }
 
 Axis::Axis(const QString& name, AxisOrientation orientation, AxisPrivate* dd)
 		: WorksheetElement(name, AspectType::Axis), d_ptr(dd) {
 	d_ptr->orientation = orientation;
 	init();
 }
 
 void Axis::finalizeAdd() {
 	Q_D(Axis);
 	d->plot = dynamic_cast<CartesianPlot*>(parentAspect());
 	Q_ASSERT(d->plot);
 	d->cSystem = dynamic_cast<const CartesianCoordinateSystem*>(d->plot->coordinateSystem());
 }
 
 void Axis::init() {
 	Q_D(Axis);
 
 	KConfig config;
 	KConfigGroup group = config.group("Axis");
 
 	d->autoScale = true;
 	d->position = Axis::AxisCustom;
 	d->offset = group.readEntry("PositionOffset", 0);
 	d->scale = (Axis::AxisScale) group.readEntry("Scale", (int) Axis::ScaleLinear);
 	d->autoScale = group.readEntry("AutoScale", true);
 	d->start = group.readEntry("Start", 0);
 	d->end = group.readEntry("End", 10);
 	d->zeroOffset = group.readEntry("ZeroOffset", 0);
 	d->scalingFactor = group.readEntry("ScalingFactor", 1.0);
 
 	d->linePen.setStyle( (Qt::PenStyle) group.readEntry("LineStyle", (int) Qt::SolidLine) );
 	d->linePen.setWidthF( group.readEntry("LineWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->lineOpacity = group.readEntry("LineOpacity", 1.0);
 	d->arrowType = (Axis::ArrowType) group.readEntry("ArrowType", (int)Axis::NoArrow);
 	d->arrowPosition = (Axis::ArrowPosition) group.readEntry("ArrowPosition", (int)Axis::ArrowRight);
 	d->arrowSize = group.readEntry("ArrowSize", Worksheet::convertToSceneUnits(10, Worksheet::Point));
 
 	// axis title
  	d->title = new TextLabel(this->name(), TextLabel::AxisTitle);
 	connect( d->title, &TextLabel::changed, this, &Axis::labelChanged);
 	addChild(d->title);
 	d->title->setHidden(true);
 	d->title->graphicsItem()->setParentItem(d);
 	d->title->graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 	d->title->graphicsItem()->setFlag(QGraphicsItem::ItemIsFocusable, false);
 	d->title->graphicsItem()->setAcceptHoverEvents(false);
 	d->title->setText(this->name());
 	if (d->orientation == AxisVertical) d->title->setRotationAngle(90);
 	d->titleOffsetX = Worksheet::convertToSceneUnits(2, Worksheet::Point); //distance to the axis tick labels
 	d->titleOffsetY = Worksheet::convertToSceneUnits(2, Worksheet::Point); //distance to the axis tick labels
 
 	d->majorTicksDirection = (Axis::TicksDirection) group.readEntry("MajorTicksDirection", (int) Axis::ticksOut);
 	d->majorTicksType = (Axis::TicksType) group.readEntry("MajorTicksType", (int) Axis::TicksTotalNumber);
 	d->majorTicksNumber = group.readEntry("MajorTicksNumber", 11);
 	d->majorTicksSpacing = group.readEntry("MajorTicksIncrement", 0.0); // set to 0, so axisdock determines the value to not have to many labels the first time switched to Spacing
 
 	d->majorTicksPen.setStyle((Qt::PenStyle) group.readEntry("MajorTicksLineStyle", (int)Qt::SolidLine) );
 	d->majorTicksPen.setColor( group.readEntry("MajorTicksColor", QColor(Qt::black) ) );
 	d->majorTicksPen.setWidthF( group.readEntry("MajorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point) ) );
 	d->majorTicksLength = group.readEntry("MajorTicksLength", Worksheet::convertToSceneUnits(6.0, Worksheet::Point));
 	d->majorTicksOpacity = group.readEntry("MajorTicksOpacity", 1.0);
 
 	d->minorTicksDirection = (Axis::TicksDirection) group.readEntry("MinorTicksDirection", (int) Axis::ticksOut);
 	d->minorTicksType = (Axis::TicksType) group.readEntry("MinorTicksType", (int) Axis::TicksTotalNumber);
 	d->minorTicksNumber = group.readEntry("MinorTicksNumber", 1);
 	d->minorTicksIncrement = group.readEntry("MinorTicksIncrement", 0.0);	// see MajorTicksIncrement
 	d->minorTicksPen.setStyle((Qt::PenStyle) group.readEntry("MinorTicksLineStyle", (int)Qt::SolidLine) );
 	d->minorTicksPen.setColor( group.readEntry("MinorTicksColor", QColor(Qt::black) ) );
 	d->minorTicksPen.setWidthF( group.readEntry("MinorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point) ) );
 	d->minorTicksLength = group.readEntry("MinorTicksLength", Worksheet::convertToSceneUnits(3.0, Worksheet::Point));
 	d->minorTicksOpacity = group.readEntry("MinorTicksOpacity", 1.0);
 
 	//Labels
 	d->labelsFormat = (Axis::LabelsFormat) group.readEntry("LabelsFormat", (int)Axis::FormatDecimal);
 	d->labelsAutoPrecision = group.readEntry("LabelsAutoPrecision", true);
 	d->labelsPrecision = group.readEntry("LabelsPrecision", 1);
 	d->labelsDateTimeFormat = group.readEntry("LabelsDateTimeFormat", "yyyy-MM-dd hh:mm:ss");
 	d->labelsPosition = (Axis::LabelsPosition) group.readEntry("LabelsPosition", (int) Axis::LabelsOut);
 	d->labelsOffset = group.readEntry("LabelsOffset",  Worksheet::convertToSceneUnits( 5.0, Worksheet::Point ));
 	d->labelsRotationAngle = group.readEntry("LabelsRotation", 0);
 	d->labelsFont = group.readEntry("LabelsFont", QFont());
 	d->labelsFont.setPixelSize( Worksheet::convertToSceneUnits( 10.0, Worksheet::Point ) );
 	d->labelsColor = group.readEntry("LabelsFontColor", QColor(Qt::black));
 	d->labelsPrefix =  group.readEntry("LabelsPrefix", "" );
 	d->labelsSuffix =  group.readEntry("LabelsSuffix", "" );
 	d->labelsOpacity = group.readEntry("LabelsOpacity", 1.0);
 
 	//major grid
 	d->majorGridPen.setStyle( (Qt::PenStyle) group.readEntry("MajorGridStyle", (int) Qt::NoPen) );
 	d->majorGridPen.setColor(group.readEntry("MajorGridColor", QColor(Qt::gray)) );
 	d->majorGridPen.setWidthF( group.readEntry("MajorGridWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->majorGridOpacity = group.readEntry("MajorGridOpacity", 1.0);
 
 	//minor grid
 	d->minorGridPen.setStyle( (Qt::PenStyle) group.readEntry("MinorGridStyle", (int) Qt::NoPen) );
 	d->minorGridPen.setColor(group.readEntry("MinorGridColor", QColor(Qt::gray)) );
 	d->minorGridPen.setWidthF( group.readEntry("MinorGridWidth", Worksheet::convertToSceneUnits( 1.0, Worksheet::Point ) ) );
 	d->minorGridOpacity = group.readEntry("MinorGridOpacity", 1.0);
 }
 
 /*!
  * For the most frequently edited properties, create Actions and ActionGroups for the context menu.
  * For some ActionGroups the actual actions are created in \c GuiTool,
  */
 void Axis::initActions() {
 	visibilityAction = new QAction(QIcon::fromTheme("view-visible"), i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, &QAction::triggered, this, &Axis::visibilityChangedSlot);
 
 	//Orientation
 	orientationActionGroup = new QActionGroup(this);
 	orientationActionGroup->setExclusive(true);
 	connect(orientationActionGroup, &QActionGroup::triggered, this, &Axis::orientationChangedSlot);
 
 	orientationHorizontalAction = new QAction(QIcon::fromTheme("labplot-axis-horizontal"), i18n("Horizontal"), orientationActionGroup);
 	orientationHorizontalAction->setCheckable(true);
 
 	orientationVerticalAction = new QAction(QIcon::fromTheme("labplot-axis-vertical"), i18n("Vertical"), orientationActionGroup);
 	orientationVerticalAction->setCheckable(true);
 
 	//Line
 	lineStyleActionGroup = new QActionGroup(this);
 	lineStyleActionGroup->setExclusive(true);
 	connect(lineStyleActionGroup, &QActionGroup::triggered, this, &Axis::lineStyleChanged);
 
 	lineColorActionGroup = new QActionGroup(this);
 	lineColorActionGroup->setExclusive(true);
 	connect(lineColorActionGroup, &QActionGroup::triggered, this, &Axis::lineColorChanged);
 
 	//Ticks
 	//TODO
 }
 
 void Axis::initMenus() {
 	this->initActions();
 
 	//Orientation
 	orientationMenu = new QMenu(i18n("Orientation"));
 	orientationMenu->setIcon(QIcon::fromTheme("labplot-axis-horizontal"));
 	orientationMenu->addAction(orientationHorizontalAction);
 	orientationMenu->addAction(orientationVerticalAction);
 
 	//Line
 	lineMenu = new QMenu(i18n("Line"));
 	lineMenu->setIcon(QIcon::fromTheme("draw-line"));
 	lineStyleMenu = new QMenu(i18n("Style"), lineMenu);
 	lineStyleMenu->setIcon(QIcon::fromTheme("object-stroke-style"));
 	lineMenu->setIcon(QIcon::fromTheme("draw-line"));
 	lineMenu->addMenu( lineStyleMenu );
 
 	lineColorMenu = new QMenu(i18n("Color"), lineMenu);
 	lineColorMenu->setIcon(QIcon::fromTheme("fill-color"));
 	GuiTools::fillColorMenu( lineColorMenu, lineColorActionGroup );
 	lineMenu->addMenu( lineColorMenu );
 }
 
 QMenu* Axis::createContextMenu() {
 	if (!orientationMenu)
 		initMenus();
 
 	Q_D(const Axis);
 	QMenu* menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1); //skip the first action because of the "title-action"
 
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 
 	//Orientation
 	if ( d->orientation == AxisHorizontal )
 		orientationHorizontalAction->setChecked(true);
 	else
 		orientationVerticalAction->setChecked(true);
 
 	menu->insertMenu(firstAction, orientationMenu);
 
 	//Line styles
 	GuiTools::updatePenStyles( lineStyleMenu, lineStyleActionGroup, d->linePen.color() );
 	GuiTools::selectPenStyleAction(lineStyleActionGroup, d->linePen.style() );
 
 	GuiTools::selectColorAction(lineColorActionGroup, d->linePen.color() );
 
 	menu->insertMenu(firstAction, lineMenu);
 	menu->insertSeparator(firstAction);
 
 	return menu;
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon Axis::icon() const{
 	Q_D(const Axis);
 	QIcon ico;
 	if (d->orientation == Axis::AxisHorizontal)
 		ico = QIcon::fromTheme("labplot-axis-horizontal");
 	else
 		ico = QIcon::fromTheme("labplot-axis-vertical");
 
 	return ico;
 }
 
 Axis::~Axis() {
 	if (orientationMenu) {
 		delete orientationMenu;
 		delete lineMenu;
 	}
 
 	//no need to delete d->title, since it was added with addChild in init();
 
 	//no need to delete the d-pointer here - it inherits from QGraphicsItem
 	//and is deleted during the cleanup in QGraphicsScene
 }
 
 QGraphicsItem *Axis::graphicsItem() const {
 	return d_ptr;
 }
 
 /*!
  * overrides the implementation in WorksheetElement and sets the z-value to the maximal possible,
  * axes are drawn on top of all other object in the plot.
  */
 void Axis::setZValue(qreal) {
 	Q_D(Axis);
 	d->setZValue(std::numeric_limits<double>::max());
 	d->gridItem->setParentItem(d->parentItem());
 	d->gridItem->setZValue(0);
 }
 
 void Axis::retransform() {
 	Q_D(Axis);
 	d->retransform();
 }
 
 void Axis::retransformTickLabelStrings() {
 	Q_D(Axis);
 	d->retransformTickLabelStrings();
 }
 
 void Axis::setSuppressRetransform(bool value) {
 	Q_D(Axis);
 	d->suppressRetransform = value;
 }
 
 void Axis::handleResize(double horizontalRatio, double verticalRatio, bool pageResize) {
 	Q_D(Axis);
 	Q_UNUSED(pageResize);
 
 	double ratio = 0;
 	if (horizontalRatio > 1.0 || verticalRatio > 1.0)
 		ratio = qMax(horizontalRatio, verticalRatio);
 	else
 		ratio = qMin(horizontalRatio, verticalRatio);
 
 	QPen pen = d->linePen;
 	pen.setWidthF(pen.widthF() * ratio);
 	d->linePen = pen;
 
 	d->majorTicksLength *= ratio; // ticks are perpendicular to axis line -> verticalRatio relevant
 	d->minorTicksLength *= ratio;
 	d->labelsFont.setPixelSize( d->labelsFont.pixelSize() * ratio ); //TODO: take into account rotated labels
 	d->labelsOffset *= ratio;
 	d->title->handleResize(horizontalRatio, verticalRatio, pageResize);
 }
 
 /* ============================ getter methods ================= */
 BASIC_SHARED_D_READER_IMPL(Axis, bool, autoScale, autoScale)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisOrientation, orientation, orientation)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisPosition, position, position)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::AxisScale, scale, scale)
 BASIC_SHARED_D_READER_IMPL(Axis, double, offset, offset)
 BASIC_SHARED_D_READER_IMPL(Axis, double, start, start)
 BASIC_SHARED_D_READER_IMPL(Axis, double, end, end)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, scalingFactor, scalingFactor)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, zeroOffset, zeroOffset)
 
 BASIC_SHARED_D_READER_IMPL(Axis, TextLabel*, title, title)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, titleOffsetX, titleOffsetX)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, titleOffsetY, titleOffsetY)
 
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, linePen, linePen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, lineOpacity, lineOpacity)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::ArrowType, arrowType, arrowType)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::ArrowPosition, arrowPosition, arrowPosition)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, arrowSize, arrowSize)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksDirection, majorTicksDirection, majorTicksDirection)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksType, majorTicksType, majorTicksType)
 BASIC_SHARED_D_READER_IMPL(Axis, int, majorTicksNumber, majorTicksNumber)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksSpacing, majorTicksSpacing)
 BASIC_SHARED_D_READER_IMPL(Axis, const AbstractColumn*, majorTicksColumn, majorTicksColumn)
 QString& Axis::majorTicksColumnPath() const { return d_ptr->majorTicksColumnPath; }
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksLength, majorTicksLength)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, majorTicksPen, majorTicksPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorTicksOpacity, majorTicksOpacity)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksDirection, minorTicksDirection, minorTicksDirection)
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::TicksType, minorTicksType, minorTicksType)
 BASIC_SHARED_D_READER_IMPL(Axis, int, minorTicksNumber, minorTicksNumber)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksSpacing, minorTicksIncrement)
 BASIC_SHARED_D_READER_IMPL(Axis, const AbstractColumn*, minorTicksColumn, minorTicksColumn)
 QString& Axis::minorTicksColumnPath() const { return d_ptr->minorTicksColumnPath; }
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksLength, minorTicksLength)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, minorTicksPen, minorTicksPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorTicksOpacity, minorTicksOpacity)
 
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::LabelsFormat, labelsFormat, labelsFormat);
 BASIC_SHARED_D_READER_IMPL(Axis, bool, labelsAutoPrecision, labelsAutoPrecision);
 BASIC_SHARED_D_READER_IMPL(Axis, int, labelsPrecision, labelsPrecision);
 BASIC_SHARED_D_READER_IMPL(Axis, QString, labelsDateTimeFormat, labelsDateTimeFormat);
 BASIC_SHARED_D_READER_IMPL(Axis, Axis::LabelsPosition, labelsPosition, labelsPosition);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsOffset, labelsOffset);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsRotationAngle, labelsRotationAngle);
 CLASS_SHARED_D_READER_IMPL(Axis, QColor, labelsColor, labelsColor);
 CLASS_SHARED_D_READER_IMPL(Axis, QFont, labelsFont, labelsFont);
 CLASS_SHARED_D_READER_IMPL(Axis, QString, labelsPrefix, labelsPrefix);
 CLASS_SHARED_D_READER_IMPL(Axis, QString, labelsSuffix, labelsSuffix);
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, labelsOpacity, labelsOpacity);
 
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, majorGridPen, majorGridPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, majorGridOpacity, majorGridOpacity)
 CLASS_SHARED_D_READER_IMPL(Axis, QPen, minorGridPen, minorGridPen)
 BASIC_SHARED_D_READER_IMPL(Axis, qreal, minorGridOpacity, minorGridOpacity)
 
 /* ============================ setter methods and undo commands ================= */
 STD_SETTER_CMD_IMPL_F_S(Axis, SetAutoScale, bool, autoScale, retransform);
 void Axis::setAutoScale(bool autoScale) {
 	Q_D(Axis);
 	if (autoScale != d->autoScale) {
 		exec(new AxisSetAutoScaleCmd(d, autoScale, ki18n("%1: set axis auto scaling")));
 
 		if (autoScale) {
 			auto* plot = qobject_cast<CartesianPlot*>(parentAspect());
 			if (!plot)
 				return;
 
 			if (d->orientation == Axis::AxisHorizontal) {
 				d->end = plot->xMax();
 				d->start = plot->xMin();
 			} else {
 				d->end = plot->yMax();
 				d->start = plot->yMin();
 			}
 			retransform();
 			emit endChanged(d->end);
 			emit startChanged(d->start);
 		}
 	}
 }
 
 STD_SWAP_METHOD_SETTER_CMD_IMPL(Axis, SetVisible, bool, swapVisible);
 void Axis::setVisible(bool on) {
 	Q_D(Axis);
 	exec(new AxisSetVisibleCmd(d, on, on ? ki18n("%1: set visible") : ki18n("%1: set invisible")));
 }
 
 bool Axis::isVisible() const {
 	Q_D(const Axis);
 	return d->isVisible();
 }
 
 void Axis::setPrinting(bool on) {
 	Q_D(Axis);
 	d->setPrinting(on);
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetOrientation, Axis::AxisOrientation, orientation, retransform);
 void Axis::setOrientation( AxisOrientation orientation) {
 	Q_D(Axis);
 	if (orientation != d->orientation)
 		exec(new AxisSetOrientationCmd(d, orientation, ki18n("%1: set axis orientation")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetPosition, Axis::AxisPosition, position, retransform);
 void Axis::setPosition(AxisPosition position) {
 	Q_D(Axis);
 	if (position != d->position)
 		exec(new AxisSetPositionCmd(d, position, ki18n("%1: set axis position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetScaling, Axis::AxisScale, scale, retransformTicks);
 void Axis::setScale(AxisScale scale) {
 	Q_D(Axis);
 	if (scale != d->scale)
 		exec(new AxisSetScalingCmd(d, scale, ki18n("%1: set axis scale")));
 }
 
 STD_SETTER_CMD_IMPL_F(Axis, SetOffset, double, offset, retransform);
 void Axis::setOffset(double offset, bool undo) {
 	Q_D(Axis);
 	if (offset != d->offset) {
 		if (undo) {
 			exec(new AxisSetOffsetCmd(d, offset, ki18n("%1: set axis offset")));
 		} else {
 			d->offset = offset;
 			//don't need to call retransform() afterward
 			//since the only usage of this call is in CartesianPlot, where retransform is called for all children anyway.
 		}
 		emit positionChanged(offset);
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetStart, double, start, retransform);
 void Axis::setStart(double start) {
 	Q_D(Axis);
 	if (start != d->start)
 		exec(new AxisSetStartCmd(d, start, ki18n("%1: set axis start")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetEnd, double, end, retransform);
 void Axis::setEnd(double end) {
 	Q_D(Axis);
 	if (end != d->end)
 		exec(new AxisSetEndCmd(d, end, ki18n("%1: set axis end")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetZeroOffset, qreal, zeroOffset, retransform);
 void Axis::setZeroOffset(qreal zeroOffset) {
 	Q_D(Axis);
 	if (zeroOffset != d->zeroOffset)
 		exec(new AxisSetZeroOffsetCmd(d, zeroOffset, ki18n("%1: set axis zero offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetScalingFactor, qreal, scalingFactor, retransform);
 void Axis::setScalingFactor(qreal scalingFactor) {
 	Q_D(Axis);
 	if (scalingFactor != d->scalingFactor)
 		exec(new AxisSetScalingFactorCmd(d, scalingFactor, ki18n("%1: set axis scaling factor")));
 }
 
 //Title
 STD_SETTER_CMD_IMPL_F_S(Axis, SetTitleOffsetX, qreal, titleOffsetX, retransform);
 void Axis::setTitleOffsetX(qreal offset) {
 	Q_D(Axis);
 	if (offset != d->titleOffsetX)
 		exec(new AxisSetTitleOffsetXCmd(d, offset, ki18n("%1: set title offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetTitleOffsetY, qreal, titleOffsetY, retransform);
 void Axis::setTitleOffsetY(qreal offset) {
 	Q_D(Axis);
 	if (offset != d->titleOffsetY)
 		exec(new AxisSetTitleOffsetYCmd(d, offset, ki18n("%1: set title offset")));
 }
 
 //Line
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLinePen, QPen, linePen, recalcShapeAndBoundingRect);
 void Axis::setLinePen(const QPen &pen) {
 	Q_D(Axis);
 	if (pen != d->linePen)
 		exec(new AxisSetLinePenCmd(d, pen, ki18n("%1: set line style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLineOpacity, qreal, lineOpacity, update);
 void Axis::setLineOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->lineOpacity)
 		exec(new AxisSetLineOpacityCmd(d, opacity, ki18n("%1: set line opacity")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowType, Axis::ArrowType, arrowType, retransformArrow);
 void Axis::setArrowType(ArrowType type) {
 	Q_D(Axis);
 	if (type != d->arrowType)
 		exec(new AxisSetArrowTypeCmd(d, type, ki18n("%1: set arrow type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowPosition, Axis::ArrowPosition, arrowPosition, retransformArrow);
 void Axis::setArrowPosition(ArrowPosition position) {
 	Q_D(Axis);
 	if (position != d->arrowPosition)
 		exec(new AxisSetArrowPositionCmd(d, position, ki18n("%1: set arrow position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetArrowSize, qreal, arrowSize, retransformArrow);
 void Axis::setArrowSize(qreal arrowSize) {
 	Q_D(Axis);
 	if (arrowSize != d->arrowSize)
 		exec(new AxisSetArrowSizeCmd(d, arrowSize, ki18n("%1: set arrow size")));
 }
 
 //Major ticks
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksDirection, Axis::TicksDirection, majorTicksDirection, retransformTicks);
 void Axis::setMajorTicksDirection(TicksDirection majorTicksDirection) {
 	Q_D(Axis);
 	if (majorTicksDirection != d->majorTicksDirection)
 		exec(new AxisSetMajorTicksDirectionCmd(d, majorTicksDirection, ki18n("%1: set major ticks direction")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksType, Axis::TicksType, majorTicksType, retransformTicks);
 void Axis::setMajorTicksType(TicksType majorTicksType) {
 	Q_D(Axis);
 	if (majorTicksType!= d->majorTicksType)
 		exec(new AxisSetMajorTicksTypeCmd(d, majorTicksType, ki18n("%1: set major ticks type")));
 }
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksNumber, int, majorTicksNumber, retransformTicks);
 void Axis::setMajorTicksNumber(int majorTicksNumber) {
 	Q_D(Axis);
 	if (majorTicksNumber != d->majorTicksNumber)
 		exec(new AxisSetMajorTicksNumberCmd(d, majorTicksNumber, ki18n("%1: set the total number of the major ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksSpacing, qreal, majorTicksSpacing, retransformTicks);
 void Axis::setMajorTicksSpacing(qreal majorTicksSpacing) {
 	Q_D(Axis);
 	if (majorTicksSpacing != d->majorTicksSpacing)
 		exec(new AxisSetMajorTicksSpacingCmd(d, majorTicksSpacing, ki18n("%1: set the spacing of the major ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksColumn, const AbstractColumn*, majorTicksColumn, retransformTicks)
 void Axis::setMajorTicksColumn(const AbstractColumn* column) {
 	Q_D(Axis);
 	if (column != d->majorTicksColumn) {
 		exec(new AxisSetMajorTicksColumnCmd(d, column, ki18n("%1: assign major ticks' values")));
 
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Axis::retransformTicks);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Axis::majorTicksColumnAboutToBeRemoved);
 			//TODO: add disconnect in the undo-function
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksPen, QPen, majorTicksPen, recalcShapeAndBoundingRect);
 void Axis::setMajorTicksPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->majorTicksPen)
 		exec(new AxisSetMajorTicksPenCmd(d, pen, ki18n("%1: set major ticks style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksLength, qreal, majorTicksLength, retransformTicks);
 void Axis::setMajorTicksLength(qreal majorTicksLength) {
 	Q_D(Axis);
 	if (majorTicksLength != d->majorTicksLength)
 		exec(new AxisSetMajorTicksLengthCmd(d, majorTicksLength, ki18n("%1: set major ticks length")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorTicksOpacity, qreal, majorTicksOpacity, update);
 void Axis::setMajorTicksOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->majorTicksOpacity)
 		exec(new AxisSetMajorTicksOpacityCmd(d, opacity, ki18n("%1: set major ticks opacity")));
 }
 
 //Minor ticks
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksDirection, Axis::TicksDirection, minorTicksDirection, retransformTicks);
 void Axis::setMinorTicksDirection(TicksDirection minorTicksDirection) {
 	Q_D(Axis);
 	if (minorTicksDirection != d->minorTicksDirection)
 		exec(new AxisSetMinorTicksDirectionCmd(d, minorTicksDirection, ki18n("%1: set minor ticks direction")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksType, Axis::TicksType, minorTicksType, retransformTicks);
 void Axis::setMinorTicksType(TicksType minorTicksType) {
 	Q_D(Axis);
 	if (minorTicksType!= d->minorTicksType)
 		exec(new AxisSetMinorTicksTypeCmd(d, minorTicksType, ki18n("%1: set minor ticks type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksNumber, int, minorTicksNumber, retransformTicks);
 void Axis::setMinorTicksNumber(int minorTicksNumber) {
 	Q_D(Axis);
 	if (minorTicksNumber != d->minorTicksNumber)
 		exec(new AxisSetMinorTicksNumberCmd(d, minorTicksNumber, ki18n("%1: set the total number of the minor ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksSpacing, qreal, minorTicksIncrement, retransformTicks);
 void Axis::setMinorTicksSpacing(qreal minorTicksSpacing) {
 	Q_D(Axis);
 	if (minorTicksSpacing != d->minorTicksIncrement)
 		exec(new AxisSetMinorTicksSpacingCmd(d, minorTicksSpacing, ki18n("%1: set the spacing of the minor ticks")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksColumn, const AbstractColumn*, minorTicksColumn, retransformTicks)
 void Axis::setMinorTicksColumn(const AbstractColumn* column) {
 	Q_D(Axis);
 	if (column != d->minorTicksColumn) {
 		exec(new AxisSetMinorTicksColumnCmd(d, column, ki18n("%1: assign minor ticks' values")));
 
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &Axis::retransformTicks);
 			connect(column->parentAspect(), &AbstractAspect::aspectAboutToBeRemoved,
 					this, &Axis::minorTicksColumnAboutToBeRemoved);
 			//TODO: add disconnect in the undo-function
 		}
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksPen, QPen, minorTicksPen, recalcShapeAndBoundingRect);
 void Axis::setMinorTicksPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->minorTicksPen)
 		exec(new AxisSetMinorTicksPenCmd(d, pen, ki18n("%1: set minor ticks style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksLength, qreal, minorTicksLength, retransformTicks);
 void Axis::setMinorTicksLength(qreal minorTicksLength) {
 	Q_D(Axis);
 	if (minorTicksLength != d->minorTicksLength)
 		exec(new AxisSetMinorTicksLengthCmd(d, minorTicksLength, ki18n("%1: set minor ticks length")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorTicksOpacity, qreal, minorTicksOpacity, update);
 void Axis::setMinorTicksOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->minorTicksOpacity)
 		exec(new AxisSetMinorTicksOpacityCmd(d, opacity, ki18n("%1: set minor ticks opacity")));
 }
 
 //Labels
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsFormat, Axis::LabelsFormat, labelsFormat, retransformTicks);
 void Axis::setLabelsFormat(LabelsFormat labelsFormat) {
 	Q_D(Axis);
 	if (labelsFormat != d->labelsFormat) {
 
 		//TODO: this part is not undo/redo-aware
 		if (labelsFormat == Axis::FormatDecimal)
 			d->labelsFormatDecimalOverruled = true;
 		else
 			d->labelsFormatDecimalOverruled = false;
 
 		exec(new AxisSetLabelsFormatCmd(d, labelsFormat, ki18n("%1: set labels format")));
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsAutoPrecision, bool, labelsAutoPrecision, retransformTickLabelStrings);
 void Axis::setLabelsAutoPrecision(bool labelsAutoPrecision) {
 	Q_D(Axis);
 	if (labelsAutoPrecision != d->labelsAutoPrecision)
 		exec(new AxisSetLabelsAutoPrecisionCmd(d, labelsAutoPrecision, ki18n("%1: set labels precision")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPrecision, int, labelsPrecision, retransformTickLabelStrings);
 void Axis::setLabelsPrecision(int labelsPrecision) {
 	Q_D(Axis);
 	if (labelsPrecision != d->labelsPrecision)
 		exec(new AxisSetLabelsPrecisionCmd(d, labelsPrecision, ki18n("%1: set labels precision")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsDateTimeFormat, QString, labelsDateTimeFormat, retransformTickLabelStrings);
 void Axis::setLabelsDateTimeFormat(const QString& format) {
 	Q_D(Axis);
 	if (format != d->labelsDateTimeFormat)
 		exec(new AxisSetLabelsDateTimeFormatCmd(d, format, ki18n("%1: set labels datetime format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPosition, Axis::LabelsPosition, labelsPosition, retransformTickLabelPositions);
 void Axis::setLabelsPosition(LabelsPosition labelsPosition) {
 	Q_D(Axis);
 	if (labelsPosition != d->labelsPosition)
 		exec(new AxisSetLabelsPositionCmd(d, labelsPosition, ki18n("%1: set labels position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsOffset, double, labelsOffset, retransformTickLabelPositions);
 void Axis::setLabelsOffset(double offset) {
 	Q_D(Axis);
 	if (offset != d->labelsOffset)
 		exec(new AxisSetLabelsOffsetCmd(d, offset, ki18n("%1: set label offset")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsRotationAngle, qreal, labelsRotationAngle, retransformTickLabelPositions);
 void Axis::setLabelsRotationAngle(qreal angle) {
 	Q_D(Axis);
 	if (angle != d->labelsRotationAngle)
 		exec(new AxisSetLabelsRotationAngleCmd(d, angle, ki18n("%1: set label rotation angle")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsColor, QColor, labelsColor, update);
 void Axis::setLabelsColor(const QColor& color) {
 	Q_D(Axis);
 	if (color != d->labelsColor)
 		exec(new AxisSetLabelsColorCmd(d, color, ki18n("%1: set label color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsFont, QFont, labelsFont, retransformTickLabelStrings);
 void Axis::setLabelsFont(const QFont& font) {
 	Q_D(Axis);
 	if (font != d->labelsFont)
 		exec(new AxisSetLabelsFontCmd(d, font, ki18n("%1: set label font")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsPrefix, QString, labelsPrefix, retransformTickLabelStrings);
 void Axis::setLabelsPrefix(const QString& prefix) {
 	Q_D(Axis);
 	if (prefix != d->labelsPrefix)
 		exec(new AxisSetLabelsPrefixCmd(d, prefix, ki18n("%1: set label prefix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsSuffix, QString, labelsSuffix, retransformTickLabelStrings);
 void Axis::setLabelsSuffix(const QString& suffix) {
 	Q_D(Axis);
 	if (suffix != d->labelsSuffix)
 		exec(new AxisSetLabelsSuffixCmd(d, suffix, ki18n("%1: set label suffix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetLabelsOpacity, qreal, labelsOpacity, update);
 void Axis::setLabelsOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->labelsOpacity)
 		exec(new AxisSetLabelsOpacityCmd(d, opacity, ki18n("%1: set labels opacity")));
 }
 
 //Major grid
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorGridPen, QPen, majorGridPen, retransformMajorGrid);
 void Axis::setMajorGridPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->majorGridPen)
 		exec(new AxisSetMajorGridPenCmd(d, pen, ki18n("%1: set major grid style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMajorGridOpacity, qreal, majorGridOpacity, updateGrid);
 void Axis::setMajorGridOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->majorGridOpacity)
 		exec(new AxisSetMajorGridOpacityCmd(d, opacity, ki18n("%1: set major grid opacity")));
 }
 
 //Minor grid
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorGridPen, QPen, minorGridPen, retransformMinorGrid);
 void Axis::setMinorGridPen(const QPen& pen) {
 	Q_D(Axis);
 	if (pen != d->minorGridPen)
 		exec(new AxisSetMinorGridPenCmd(d, pen, ki18n("%1: set minor grid style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Axis, SetMinorGridOpacity, qreal, minorGridOpacity, updateGrid);
 void Axis::setMinorGridOpacity(qreal opacity) {
 	Q_D(Axis);
 	if (opacity != d->minorGridOpacity)
 		exec(new AxisSetMinorGridOpacityCmd(d, opacity, ki18n("%1: set minor grid opacity")));
 }
 
 //##############################################################################
 //####################################  SLOTs   ################################
 //##############################################################################
 void Axis::labelChanged() {
 	Q_D(Axis);
 	d->recalcShapeAndBoundingRect();
 }
 
 void Axis::retransformTicks() {
 	Q_D(Axis);
 	d->retransformTicks();
 }
 
 void Axis::majorTicksColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Axis);
 	if (aspect == d->majorTicksColumn) {
 		d->majorTicksColumn = nullptr;
 		d->retransformTicks();
 	}
 }
 
 void Axis::minorTicksColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(Axis);
 	if (aspect == d->minorTicksColumn) {
 		d->minorTicksColumn = nullptr;
 		d->retransformTicks();
 	}
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void Axis::orientationChangedSlot(QAction* action) {
 	if (action == orientationHorizontalAction)
 		this->setOrientation(AxisHorizontal);
 	else
 		this->setOrientation(AxisVertical);
 }
 
 void Axis::lineStyleChanged(QAction* action) {
 	Q_D(const Axis);
 	QPen pen = d->linePen;
 	pen.setStyle(GuiTools::penStyleFromAction(lineStyleActionGroup, action));
 	this->setLinePen(pen);
 }
 
 void Axis::lineColorChanged(QAction* action) {
 	Q_D(const Axis);
 	QPen pen = d->linePen;
 	pen.setColor(GuiTools::colorFromAction(lineColorActionGroup, action));
 	this->setLinePen(pen);
 }
 
 void Axis::visibilityChangedSlot() {
 	Q_D(const Axis);
 	this->setVisible(!d->isVisible());
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 AxisPrivate::AxisPrivate(Axis* owner) : gridItem(new AxisGrid(this)), q(owner) {
 	setFlag(QGraphicsItem::ItemIsSelectable, true);
 	setFlag(QGraphicsItem::ItemIsFocusable, true);
 	setAcceptHoverEvents(true);
 }
 
 QString AxisPrivate::name() const{
 	return q->name();
 }
 
 bool AxisPrivate::swapVisible(bool on) {
 	bool oldValue = isVisible();
 	setVisible(on);
 	emit q->visibilityChanged(on);
 	return oldValue;
 }
 
 QRectF AxisPrivate::boundingRect() const{
 	return boundingRectangle;
 }
 
 /*!
   Returns the shape of the XYCurve as a QPainterPath in local coordinates
 */
 QPainterPath AxisPrivate::shape() const{
 	return axisShape;
 }
 
 /*!
 	recalculates the position of the axis on the worksheet
  */
 void AxisPrivate::retransform() {
 	if (suppressRetransform || !plot)
 		return;
 
 // 	PERFTRACE(name().toLatin1() + ", AxisPrivate::retransform()");
 	m_suppressRecalc = true;
 	retransformLine();
 	m_suppressRecalc = false;
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformLine() {
 	if (suppressRetransform)
 		return;
 
 	linePath = QPainterPath();
 	lines.clear();
 
 	QPointF startPoint;
 	QPointF endPoint;
 
 	if (orientation == Axis::AxisHorizontal) {
 		if (position == Axis::AxisTop)
 			offset = plot->yMax();
 		else if (position == Axis::AxisBottom)
 			offset = plot->yMin();
 		else if (position == Axis::AxisCentered)
 			offset = plot->yMin() + (plot->yMax()-plot->yMin())/2;
 
 		startPoint.setX(start);
 		startPoint.setY(offset);
 		endPoint.setX(end);
 		endPoint.setY(offset);
 	} else { // vertical
 		if (position == Axis::AxisLeft)
 			offset = plot->xMin();
 		else if (position == Axis::AxisRight)
 			offset = plot->xMax();
 		else if (position == Axis::AxisCentered)
 			offset = plot->xMin() + (plot->xMax()-plot->xMin())/2;
 
 		startPoint.setX(offset);
 		startPoint.setY(start);
 		endPoint.setY(end);
 		endPoint.setX(offset);
 	}
 
 	lines.append(QLineF(startPoint, endPoint));
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::MarkGaps);
 	for (const auto& line : lines) {
 		linePath.moveTo(line.p1());
 		linePath.lineTo(line.p2());
 	}
 
 	if (linePath.isEmpty()) {
 		recalcShapeAndBoundingRect();
 		return;
 	} else {
 		retransformArrow();
 		retransformTicks();
 	}
 }
 
 void AxisPrivate::retransformArrow() {
 	if (suppressRetransform)
 		return;
 
 	arrowPath = QPainterPath();
 	if (arrowType == Axis::NoArrow || lines.isEmpty()) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	if (arrowPosition == Axis::ArrowRight || arrowPosition == Axis::ArrowBoth) {
 		const QPointF& endPoint = lines.at(lines.size()-1).p2();
 		this->addArrow(endPoint, 1);
 	}
 
 	if (arrowPosition == Axis::ArrowLeft || arrowPosition == Axis::ArrowBoth) {
 		const QPointF& endPoint = lines.at(0).p1();
 		this->addArrow(endPoint, -1);
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::addArrow(QPointF startPoint, int direction) {
 	static const double cos_phi = cos(M_PI/6.);
 
 	if (orientation == Axis::AxisHorizontal) {
 		QPointF endPoint = QPointF(startPoint.x() + direction*arrowSize, startPoint.y());
 		arrowPath.moveTo(startPoint);
 		arrowPath.lineTo(endPoint);
 
 		switch (arrowType) {
 			case Axis::NoArrow:
 				break;
 			case Axis::SimpleArrowSmall:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				break;
 			case Axis::SimpleArrowBig:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				break;
 			case Axis::FilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::FilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()-arrowSize/4*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/8, endPoint.y()));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()+arrowSize/4*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()-arrowSize/2*cos_phi));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/4, endPoint.y()));
 				arrowPath.lineTo(QPointF(endPoint.x()-direction*arrowSize/2, endPoint.y()+arrowSize/2*cos_phi));
 				arrowPath.lineTo(endPoint);
 				break;
 		}
 	} else { //vertical orientation
 		QPointF endPoint = QPointF(startPoint.x(), startPoint.y()-direction*arrowSize);
 		arrowPath.moveTo(startPoint);
 		arrowPath.lineTo(endPoint);
 
 		switch (arrowType) {
 			case Axis::NoArrow:
 				break;
 			case Axis::SimpleArrowSmall:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				break;
 			case Axis::SimpleArrowBig:
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.moveTo(endPoint);
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				break;
 			case Axis::FilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::FilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowSmall:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x(), endPoint.y()+direction*arrowSize/8));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/4*cos_phi, endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(endPoint);
 				break;
 			case Axis::SemiFilledArrowBig:
 				arrowPath.lineTo(QPointF(endPoint.x()-arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(QPointF(endPoint.x(), endPoint.y()+direction*arrowSize/4));
 				arrowPath.lineTo(QPointF(endPoint.x()+arrowSize/2*cos_phi, endPoint.y()+direction*arrowSize/2));
 				arrowPath.lineTo(endPoint);
 				break;
 		}
 	}
 }
 
 //! helper function for retransformTicks()
 bool AxisPrivate::transformAnchor(QPointF* anchorPoint) {
 	QVector<QPointF> points;
 	points.append(*anchorPoint);
 	points = cSystem->mapLogicalToScene(points);
 
 	if (points.count() != 1) { // point is not mappable or in a coordinate gap
 		return false;
 	} else {
 		*anchorPoint = points.at(0);
 		return true;
 	}
 }
 
 /*!
 	recalculates the position of the axis ticks.
  */
 void AxisPrivate::retransformTicks() {
 	if (suppressRetransform)
 		return;
 
 	//TODO: check that start and end are > 0 for log and >=0 for sqrt, etc.
 
 	majorTicksPath = QPainterPath();
 	minorTicksPath = QPainterPath();
 	majorTickPoints.clear();
 	minorTickPoints.clear();
 	tickLabelValues.clear();
 
 	if ( majorTicksNumber < 1 || (majorTicksDirection == Axis::noTicks && minorTicksDirection == Axis::noTicks) ) {
 		retransformTickLabelPositions(); //this calls recalcShapeAndBoundingRect()
 		return;
 	}
 
 	//determine the increment for the major ticks
 	double majorTicksIncrement = 0;
 	int tmpMajorTicksNumber = 0;
 	if (majorTicksType == Axis::TicksTotalNumber) {
 		//the total number of major ticks is given - > determine the increment
 		tmpMajorTicksNumber = majorTicksNumber;
 		switch (scale) {
 			case Axis::ScaleLinear:
 				majorTicksIncrement = (end-start)/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLog10:
 				majorTicksIncrement = (log10(end)-log10(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLog2:
 				majorTicksIncrement = (log(end)-log(start))/log(2)/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleLn:
 				majorTicksIncrement = (log(end)-log(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleSqrt:
 				majorTicksIncrement = (sqrt(end)-sqrt(start))/(majorTicksNumber-1);
 				break;
 			case Axis::ScaleX2:
 				majorTicksIncrement = (end*end - start*start)/(majorTicksNumber-1);
 		}
 	} else if (majorTicksType == Axis::TicksSpacing) {
 		//the increment of the major ticks is given -> determine the number
 		majorTicksIncrement = majorTicksSpacing * GSL_SIGN(end-start);
 		switch (scale) {
 			case Axis::ScaleLinear:
 				tmpMajorTicksNumber = qRound((end-start)/majorTicksIncrement + 1);
 				break;
 			case Axis::ScaleLog10:
 				tmpMajorTicksNumber = qRound((log10(end)-log10(start))/majorTicksIncrement + 1);
 				break;
 			case Axis::ScaleLog2:
 				tmpMajorTicksNumber = qRound((log(end)-log(start))/log(2)/majorTicksIncrement + 1);
 				break;
 			case Axis::ScaleLn:
 				tmpMajorTicksNumber = qRound((log(end)-log(start))/majorTicksIncrement + 1);
 				break;
 			case Axis::ScaleSqrt:
 				tmpMajorTicksNumber = qRound((sqrt(end)-sqrt(start))/majorTicksIncrement + 1);
 				break;
 			case Axis::ScaleX2:
 				tmpMajorTicksNumber = qRound((end*end - start*start)/majorTicksIncrement + 1);
 		}
 	} else { //custom column was provided
 		if (majorTicksColumn) {
 			tmpMajorTicksNumber = majorTicksColumn->rowCount();
 		} else {
 			retransformTickLabelPositions(); //this calls recalcShapeAndBoundingRect()
 			return;
 		}
 	}
 
 	int tmpMinorTicksNumber;
 	if (minorTicksType == Axis::TicksTotalNumber)
 		tmpMinorTicksNumber = minorTicksNumber;
 	else if (minorTicksType == Axis::TicksSpacing)
 		tmpMinorTicksNumber = fabs(end - start)/ (majorTicksNumber - 1)/minorTicksIncrement - 1;
 	else
 		(minorTicksColumn) ? tmpMinorTicksNumber = minorTicksColumn->rowCount() : tmpMinorTicksNumber = 0;
 
 	QPointF anchorPoint;
 	QPointF startPoint;
 	QPointF endPoint;
 	qreal majorTickPos = 0.0;
 	qreal minorTickPos;
 	qreal nextMajorTickPos = 0.0;
 	const int xDirection = cSystem->xDirection();
 	const int yDirection = cSystem->yDirection();
 	const double middleX = plot->xMin() + (plot->xMax() - plot->xMin())/2;
 	const double middleY = plot->yMin() + (plot->yMax() - plot->yMin())/2;
 	bool valid;
 
 	//DEBUG("tmpMajorTicksNumber = " << tmpMajorTicksNumber)
 	for (int iMajor = 0; iMajor < tmpMajorTicksNumber; iMajor++) {
 		//DEBUG("major tick " << iMajor)
 		//calculate major tick's position
 		if (majorTicksType != Axis::TicksCustomColumn) {
 			switch (scale) {
 				case Axis::ScaleLinear:
 					majorTickPos = start + majorTicksIncrement * iMajor;
 					nextMajorTickPos = majorTickPos + majorTicksIncrement;
 					break;
 				case Axis::ScaleLog10:
 					majorTickPos = start * pow(10, majorTicksIncrement*iMajor);
 					nextMajorTickPos = majorTickPos * pow(10, majorTicksIncrement);
 					break;
 				case Axis::ScaleLog2:
 					majorTickPos = start * pow(2, majorTicksIncrement*iMajor);
 					nextMajorTickPos = majorTickPos * pow(2, majorTicksIncrement);
 					break;
 				case Axis::ScaleLn:
 					majorTickPos = start * exp(majorTicksIncrement*iMajor);
 					nextMajorTickPos = majorTickPos * exp(majorTicksIncrement);
 					break;
 				case Axis::ScaleSqrt:
 					majorTickPos = pow(sqrt(start) + majorTicksIncrement*iMajor, 2);
 					nextMajorTickPos = pow(sqrt(start) + majorTicksIncrement*(iMajor+1), 2);
 					break;
 				case Axis::ScaleX2:
 					majorTickPos = sqrt(start*start + majorTicksIncrement*iMajor);
 					nextMajorTickPos = sqrt(start*start + majorTicksIncrement*(iMajor+1));
 					break;
 			}
 		} else {	// custom column
 			if (!majorTicksColumn->isValid(iMajor) || majorTicksColumn->isMasked(iMajor))
 				continue;
 			majorTickPos = majorTicksColumn->valueAt(iMajor);
 			// set next major tick pos for minor ticks
 			if (iMajor < tmpMajorTicksNumber - 1) {
 				if (majorTicksColumn->isValid(iMajor+1) && !majorTicksColumn->isMasked(iMajor+1))
 					nextMajorTickPos = majorTicksColumn->valueAt(iMajor+1);
 			} else	// last major tick
 				tmpMinorTicksNumber = 0;
 		}
 
 		//calculate start and end points for major tick's line
 		if (majorTicksDirection != Axis::noTicks) {
 			if (orientation == Axis::AxisHorizontal) {
 				anchorPoint.setX(majorTickPos);
 				anchorPoint.setY(offset);
 				valid = transformAnchor(&anchorPoint);
 				if (valid) {
 					if (offset < middleY) {
 						startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn)  ? yDirection * majorTicksLength  : 0);
 						endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut) ? -yDirection * majorTicksLength : 0);
 					} else {
 						startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut)  ? yDirection * majorTicksLength  : 0);
 						endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn) ? -yDirection * majorTicksLength : 0);
 					}
 				}
 			} else { // vertical
 				anchorPoint.setY(majorTickPos);
 				anchorPoint.setX(offset);
 				valid = transformAnchor(&anchorPoint);
 
 				if (valid) {
 					if (offset < middleX) {
 						startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? xDirection * majorTicksLength  : 0, 0);
 						endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? -xDirection * majorTicksLength : 0, 0);
 					} else {
 						startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? xDirection * majorTicksLength : 0, 0);
 						endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? -xDirection *  majorTicksLength  : 0, 0);
 					}
 				}
 			}
 
 			double value = scalingFactor * majorTickPos + zeroOffset;
 
 			//if custom column is used, we can have duplicated values in it and we need only unique values
 			if (majorTicksType == Axis::TicksCustomColumn && tickLabelValues.indexOf(value) != -1)
 				valid = false;
 
 			//add major tick's line to the painter path
 			if (valid) {
 				majorTicksPath.moveTo(startPoint);
 				majorTicksPath.lineTo(endPoint);
 				majorTickPoints << anchorPoint;
 				tickLabelValues << value;
 			}
 		}
 
 		//minor ticks
 		//DEBUG("	tmpMinorTicksNumber = " << tmpMinorTicksNumber)
 		if (Axis::noTicks != minorTicksDirection && tmpMajorTicksNumber > 1 && tmpMinorTicksNumber > 0 && iMajor < tmpMajorTicksNumber - 1 && nextMajorTickPos != majorTickPos) {
 			//minor ticks are placed at equidistant positions independent of the selected scaling for the major ticks positions
 			double minorTicksIncrement = (nextMajorTickPos - majorTickPos)/(tmpMinorTicksNumber + 1);
 			//DEBUG("	nextMajorTickPos = " << nextMajorTickPos)
 			//DEBUG("	majorTickPos = " << majorTickPos)
 			//DEBUG("	minorTicksIncrement = " << minorTicksIncrement)
 
 			for (int iMinor = 0; iMinor < tmpMinorTicksNumber; iMinor++) {
 				//calculate minor tick's position
 				if (minorTicksType != Axis::TicksCustomColumn) {
 					minorTickPos = majorTickPos + (iMinor + 1) * minorTicksIncrement;
 				} else {
 					if (!minorTicksColumn->isValid(iMinor) || minorTicksColumn->isMasked(iMinor))
 						continue;
 					minorTickPos = minorTicksColumn->valueAt(iMinor);
 
 					//in the case a custom column is used for the minor ticks, we draw them _once_ for the whole range of the axis.
 					//execute the minor ticks loop only once.
 					if (iMajor > 0)
 						break;
 				}
 				//DEBUG("		minorTickPos = " << minorTickPos)
 
 				//calculate start and end points for minor tick's line
 				if (orientation == Axis::AxisHorizontal) {
 					anchorPoint.setX(minorTickPos);
 					anchorPoint.setY(offset);
 					valid = transformAnchor(&anchorPoint);
 
 					if (valid) {
 						if (offset < middleY) {
 							startPoint = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksIn)  ? yDirection * minorTicksLength  : 0);
 							endPoint   = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksOut) ? -yDirection * minorTicksLength : 0);
 						} else {
 							startPoint = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksOut)  ? yDirection * minorTicksLength  : 0);
 							endPoint   = anchorPoint + QPointF(0, (minorTicksDirection & Axis::ticksIn) ? -yDirection * minorTicksLength : 0);
 						}
 					}
 				} else { // vertical
 					anchorPoint.setY(minorTickPos);
 					anchorPoint.setX(offset);
 					valid = transformAnchor(&anchorPoint);
 
 					if (valid) {
 						if (offset < middleX) {
 							startPoint = anchorPoint + QPointF((minorTicksDirection & Axis::ticksIn)  ? xDirection * minorTicksLength  : 0, 0);
 							endPoint   = anchorPoint + QPointF((minorTicksDirection & Axis::ticksOut) ? -xDirection * minorTicksLength : 0, 0);
 						} else {
 							startPoint = anchorPoint + QPointF((minorTicksDirection & Axis::ticksOut)  ? xDirection * minorTicksLength  : 0, 0);
 							endPoint   = anchorPoint + QPointF((minorTicksDirection & Axis::ticksIn) ? -xDirection * minorTicksLength : 0, 0);
 						}
 					}
 				}
 
 				//add minor tick's line to the painter path
 				if (valid) {
 					minorTicksPath.moveTo(startPoint);
 					minorTicksPath.lineTo(endPoint);
 					minorTickPoints << anchorPoint;
 				}
 			}
 		}
 	}
 
 	//tick positions where changed -> update the position of the tick labels and grid lines
 	retransformTickLabelStrings();
 	retransformMajorGrid();
 	retransformMinorGrid();
 }
 
 /*!
 	creates the tick label strings starting with the most optimal
 	(=the smallest possible number of float digits) precision for the floats
 */
 void AxisPrivate::retransformTickLabelStrings() {
 	if (suppressRetransform)
 		return;
 
 	//DEBUG("AxisPrivate::retransformTickLabelStrings()");
 	if (labelsAutoPrecision) {
 		//check, whether we need to increase the current precision
 		int newPrecision = upperLabelsPrecision(labelsPrecision);
 		if (newPrecision != labelsPrecision) {
 			labelsPrecision = newPrecision;
 			emit q->labelsPrecisionChanged(labelsPrecision);
 		} else {
 			//check, whether we can reduce the current precision
 			newPrecision = lowerLabelsPrecision(labelsPrecision);
 			if (newPrecision != labelsPrecision) {
 				labelsPrecision = newPrecision;
 				emit q->labelsPrecisionChanged(labelsPrecision);
 			}
 		}
 	}
 	//DEBUG("labelsPrecision =" << labelsPrecision);
 
 	//automatically switch from 'decimal' to 'scientific' format for big numbers (>10^4)
 	//and back to decimal when the numbers get smaller after the auto-switch again
 	if (labelsFormat == Axis::FormatDecimal && !labelsFormatDecimalOverruled) {
 		for (auto value : tickLabelValues) {
 			if (std::abs(value) > 1e4) {
 				labelsFormat = Axis::FormatScientificE;
 				emit q->labelsFormatChanged(labelsFormat);
 				labelsFormatAutoChanged = true;
 				break;
 			}
 		}
 	} else if (labelsFormatAutoChanged ) {
 		//check whether we still have big numbers
 		bool changeBack = true;
 		for (auto value : tickLabelValues) {
 			if (std::abs(value) > 1e4) {
 				changeBack = false;
 				break;
 			}
 		}
 
 		if (changeBack) {
 			labelsFormatAutoChanged = false;
 			labelsFormat = Axis::FormatDecimal;
 			emit q->labelsFormatChanged(labelsFormat);
 		}
 	}
 
 	tickLabelStrings.clear();
 	QString str;
 	if ( (orientation == Axis::AxisHorizontal && plot->xRangeFormat() == CartesianPlot::Numeric)
 		|| (orientation == Axis::AxisVertical && plot->yRangeFormat() == CartesianPlot::Numeric) ) {
 		if (labelsFormat == Axis::FormatDecimal) {
 			QString nullStr = QString::number(0, 'f', labelsPrecision);
 			for (const auto value : tickLabelValues) {
 				str = QString::number(value, 'f', labelsPrecision);
 				if (str == "-" + nullStr) str = nullStr;
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatScientificE) {
 			QString nullStr = QString::number(0, 'e', labelsPrecision);
 			for (const auto value : tickLabelValues) {
 				str = QString::number(value, 'e', labelsPrecision);
 				if (str == "-" + nullStr) str = nullStr;
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowers10) {
 			for (const auto value : tickLabelValues) {
 				str = "10<span style=\"vertical-align:super\">" + QString::number(log10(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowers2) {
 			for (const auto value : tickLabelValues) {
 				str = "2<span style=\"vertical-align:super\">" + QString::number(log2(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatPowersE) {
 			for (const auto value : tickLabelValues) {
 				str = "e<span style=\"vertical-align:super\">" + QString::number(log(value), 'f', labelsPrecision) + "</span>";
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		} else if (labelsFormat == Axis::FormatMultipliesPi) {
 			for (const auto value : tickLabelValues) {
 				str = "<span>" + QString::number(value / M_PI, 'f', labelsPrecision) + "</span>" + QChar(0x03C0);
 				str = labelsPrefix + str + labelsSuffix;
 				tickLabelStrings << str;
 			}
 		}
 	} else {
 		for (const auto value : tickLabelValues) {
 			QDateTime dateTime;
 			dateTime.setMSecsSinceEpoch(value);
 			str = dateTime.toString(labelsDateTimeFormat);
 			str = labelsPrefix + str + labelsSuffix;
 			tickLabelStrings << str;
 		}
 	}
 
 	//recalculate the position of the tick labels
 	retransformTickLabelPositions();
 }
 
 /*!
 	returns the smallest upper limit for the precision
 	where no duplicates for the tick label float occur.
  */
 int AxisPrivate::upperLabelsPrecision(int precision) {
 	//DEBUG("AxisPrivate::upperLabelsPrecision() precision =" << precision);
 	//round float to the current precision and look for duplicates.
 	//if there are duplicates, increase the precision.
 	QVector<double> tempValues;
 	for (const auto value : tickLabelValues)
 		tempValues.append( nsl_math_round_places(value, precision) );
 
 	for (int i = 0; i < tempValues.size(); ++i) {
 		for (int j = 0; j < tempValues.size(); ++j) {
 			if (i == j)
 				continue;
 
 			if (tempValues.at(i) == tempValues.at(j)) {
 			//duplicate for the current precision found, increase the precision and check again
 			return upperLabelsPrecision(precision + 1);
 			}
 		}
 	}
 
 	//no duplicates for the current precision found: return the current value
 	//DEBUG("	upper precision = " << precision);
 	return precision;
 }
 
 /*!
 	returns highest lower limit for the precision
 	where no duplicates for the tick label float occur.
 */
 int AxisPrivate::lowerLabelsPrecision(int precision) {
 // 	DEBUG("AxisPrivate::lowerLabelsPrecision() precision =" << precision);
 	//round float to the current precision and look for duplicates.
 	//if there are duplicates, decrease the precision.
 	QVector<double> tempValues;
 	for (const auto value : tickLabelValues)
 		tempValues.append( nsl_math_round_places(value, precision-1) );
 
 	for (int i = 0; i < tempValues.size(); ++i) {
 		for (int j = 0; j < tempValues.size(); ++j) {
 			if (i == j) continue;
 			if (tempValues.at(i) == tempValues.at(j)) {
 				//duplicate found for the reduced precision
 				//-> current precision cannot be reduced, return the current value
 // 				DEBUG("	lower precision = " << precision);
 				return precision;
 			}
 		}
 	}
 
 	//no duplicates found, reduce further, and check again
 	if (precision == 0)
 		return 0;
 	else
 		return lowerLabelsPrecision(precision - 1);
 }
 
 /*!
 	recalculates the position of the tick labels.
 	Called when the geometry related properties (position, offset, font size, suffix, prefix) of the labels are changed.
  */
 void AxisPrivate::retransformTickLabelPositions() {
 	tickLabelPoints.clear();
 	if (majorTicksDirection == Axis::noTicks || labelsPosition == Axis::NoLabels) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	QFontMetrics fm(labelsFont);
 	double width = 0;
 	double height = fm.ascent();
 	QPointF pos;
 	const double middleX = plot->xMin() + (plot->xMax() - plot->xMin())/2;
 	const double middleY = plot->yMin() + (plot->yMax() - plot->yMin())/2;
 	const int xDirection = cSystem->xDirection();
 	const int yDirection = cSystem->yDirection();
 
 	QPointF startPoint, endPoint, anchorPoint;
 
 	QTextDocument td;
 	td.setDefaultFont(labelsFont);
 	double cosine = cos(labelsRotationAngle * M_PI / 180.); // calculate only one time
 	double sine = sin(labelsRotationAngle * M_PI / 180.); // calculate only one time
 	for ( int i = 0; i < majorTickPoints.size(); i++ ) {
 		if ((orientation == Axis::AxisHorizontal && plot->xRangeFormat() == CartesianPlot::Numeric) ||
 				(orientation == Axis::AxisVertical && plot->yRangeFormat() == CartesianPlot::Numeric)) {
 			if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 				width = fm.boundingRect(tickLabelStrings.at(i)).width();
 			} else {
 				td.setHtml(tickLabelStrings.at(i));
 				width = td.size().width();
 				height = td.size().height();
 			}
 		} else { // Datetime
 			width = fm.boundingRect(tickLabelStrings.at(i)).width();
 		}
 
 		double diffx = cosine * width;
 		double diffy = sine * width;
 		anchorPoint = majorTickPoints.at(i);
 
 		//center align all labels with respect to the end point of the tick line
 		if (orientation == Axis::AxisHorizontal) {
 			if (offset < middleY) {
 				startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn)  ? yDirection * majorTicksLength  : 0);
 				endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut) ? -yDirection * majorTicksLength : 0);
 			} else {
 				startPoint = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksOut)  ? yDirection * majorTicksLength  : 0);
 				endPoint   = anchorPoint + QPointF(0, (majorTicksDirection & Axis::ticksIn) ? -yDirection * majorTicksLength : 0);
 			}
 
 			// for rotated labels (angle is not zero), align label's corner at the position of the tick
 			if (fabs(fabs(labelsRotationAngle) - 180.) < 1.e-2) { // +-180°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() + width/2);
 					pos.setY(endPoint.y() + labelsOffset );
 				} else {
 					pos.setX(startPoint.x() + width/2);
 					pos.setY(startPoint.y() - height - labelsOffset);
 				}
 			} else if (labelsRotationAngle <= -0.01) { // [-0.01°, -180°)
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() + sine * height/2);
 					pos.setY(endPoint.y() + labelsOffset + cosine * height/2);
 				} else {
 					pos.setX(startPoint.x() + sine * height/2 - diffx);
 					pos.setY(startPoint.y() - labelsOffset + cosine * height/2 + diffy);
 				}
 			} else if (labelsRotationAngle >= 0.01) { // [0.01°, 180°)
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - diffx + sine * height/2);
 					pos.setY(endPoint.y() + labelsOffset + diffy + cosine * height/2);
 				} else {
 					pos.setX(startPoint.x() + sine * height/2);
 					pos.setY(startPoint.y() - labelsOffset + cosine * height/2);
 				}
 			} else {	// 0°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - width/2);
 					pos.setY(endPoint.y() + height + labelsOffset);
 				} else {
 					pos.setX(startPoint.x() - width/2);
 					pos.setY(startPoint.y() - labelsOffset);
 				}
 			}
 		// ---------------------- vertical -------------------------
 		} else {
 			if (offset < middleX) {
 				startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? xDirection * majorTicksLength  : 0, 0);
 				endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? -xDirection * majorTicksLength : 0, 0);
 			} else {
 				startPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksOut) ? xDirection * majorTicksLength : 0, 0);
 				endPoint = anchorPoint + QPointF((majorTicksDirection & Axis::ticksIn)  ? -xDirection *  majorTicksLength  : 0, 0);
 			}
 
 			if (fabs(labelsRotationAngle - 90.) < 1.e-2) { // +90°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - labelsOffset);
 					pos.setY(endPoint.y() + width/2 );
 				} else {
 					pos.setX(startPoint.x() + labelsOffset);
 					pos.setY(startPoint.y() + width/2);
 				}
 			} else if (fabs(labelsRotationAngle + 90.) < 1.e-2) { // -90°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - labelsOffset - height);
 					pos.setY(endPoint.y() - width/2);
 				} else {
 					pos.setX(startPoint.x() + labelsOffset);
 					pos.setY(startPoint.y() - width/2);
 				}
 			} else if (fabs(fabs(labelsRotationAngle) - 180.) < 1.e-2) { // +-180°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - labelsOffset);
 					pos.setY(endPoint.y() - height/2);
 				} else {
 					pos.setX(startPoint.x() + labelsOffset + width);
 					pos.setY(startPoint.y() - height/2);
 				}
 			} else if (fabs(labelsRotationAngle) >= 0.01 && fabs(labelsRotationAngle) <= 89.99) { // [0.01°, 90°)
 				if (labelsPosition == Axis::LabelsOut) {
 					// left
 					pos.setX(endPoint.x() - labelsOffset - diffx + sine * height/2);
 					pos.setY(endPoint.y() + cosine * height/2 + diffy);
 				} else {
 					pos.setX(startPoint.x() + labelsOffset + sine * height/2);
 					pos.setY(startPoint.y() + cosine * height/2);
 				}
 			} else if (fabs(labelsRotationAngle) >= 90.01 && fabs(labelsRotationAngle) <= 179.99) { // [90.01, 180)
 				if (labelsPosition == Axis::LabelsOut) {
 					// left
 					pos.setX(endPoint.x() - labelsOffset + sine * height/2);
 					pos.setY(endPoint.y() + cosine * height/2);
 				} else {
 					pos.setX(startPoint.x() + labelsOffset - diffx + sine * height/2);
 					pos.setY(startPoint.y() + diffy + cosine * height/2);
 				}
 			} else { // 0°
 				if (labelsPosition == Axis::LabelsOut) {
 					pos.setX(endPoint.x() - width - labelsOffset);
 					pos.setY(endPoint.y() + height/2);
 				} else {
 					pos.setX(startPoint.x() + labelsOffset);
 					pos.setY(startPoint.y() + height/2);
 				}
 			}
 		}
 		tickLabelPoints << pos;
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformMajorGrid() {
 	if (suppressRetransform)
 		return;
 
 	majorGridPath = QPainterPath();
 	if (majorGridPen.style() == Qt::NoPen || majorTickPoints.size() == 0) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//major tick points are already in scene coordinates, convert them back to logical...
 	//TODO: mapping should work without SuppressPageClipping-flag, check float comparisons in the map-function.
 	//Currently, grid lines disappear somtimes without this flag
 	QVector<QPointF> logicalMajorTickPoints = cSystem->mapSceneToLogical(majorTickPoints, AbstractCoordinateSystem::SuppressPageClipping);
 
 	if (logicalMajorTickPoints.isEmpty())
 		return;
 
 	//TODO:
 	//when iterating over all grid lines, skip the first and the last points for auto scaled axes,
 	//since we don't want to paint any grid lines at the plot boundaries
 	bool skipLowestTick, skipUpperTick;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		skipLowestTick = qFuzzyCompare(logicalMajorTickPoints.at(0).x(), plot->xMin());
 		skipUpperTick = qFuzzyCompare(logicalMajorTickPoints.at(logicalMajorTickPoints.size()-1).x(), plot->xMax());
 	} else {
 		skipLowestTick = qFuzzyCompare(logicalMajorTickPoints.at(0).y(), plot->yMin());
 		skipUpperTick = qFuzzyCompare(logicalMajorTickPoints.at(logicalMajorTickPoints.size()-1).y(), plot->yMax());
 	}
 
 	int start, end;
 	if (skipLowestTick) {
 		if (logicalMajorTickPoints.size() > 1)
 			start = 1;
 		else
 			start = 0;
 	} else {
 		start = 0;
 	}
 
 	if (skipUpperTick) {
 		if (logicalMajorTickPoints.size() > 1)
 			end = logicalMajorTickPoints.size() - 1;
 		else
 			end = 0;
 
 	} else {
 		end = logicalMajorTickPoints.size();
 	}
 
 	QVector<QLineF> lines;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		double yMin = plot->yMin();
 		double yMax = plot->yMax();
 
 		for (int i = start; i < end; ++i) {
 			const QPointF& point = logicalMajorTickPoints.at(i);
 			lines.append( QLineF(point.x(), yMin, point.x(), yMax) );
 		}
 	} else { //vertical axis
 		double xMin = plot->xMin();
 		double xMax = plot->xMax();
 
 		//skip the first and the last points, since we don't want to paint any grid lines at the plot boundaries
 		for (int i = start; i < end; ++i) {
 			const QPointF& point = logicalMajorTickPoints.at(i);
 			lines.append( QLineF(xMin, point.y(), xMax, point.y()) );
 		}
 	}
 
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::SuppressPageClipping);
 	for (const auto& line : lines) {
 		majorGridPath.moveTo(line.p1());
 		majorGridPath.lineTo(line.p2());
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void AxisPrivate::retransformMinorGrid() {
 	if (suppressRetransform)
 		return;
 
 	minorGridPath = QPainterPath();
 	if (minorGridPen.style() == Qt::NoPen) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//minor tick points are already in scene coordinates, convert them back to logical...
 	//TODO: mapping should work without SuppressPageClipping-flag, check float comparisons in the map-function.
 	//Currently, grid lines disappear somtimes without this flag
 	QVector<QPointF> logicalMinorTickPoints = cSystem->mapSceneToLogical(minorTickPoints, AbstractCoordinateSystem::SuppressPageClipping);
 
 	QVector<QLineF> lines;
 	if (orientation == Axis::AxisHorizontal) { //horizontal axis
 		double yMin = plot->yMin();
 		double yMax = plot->yMax();
 
 		for (const auto point : logicalMinorTickPoints)
 			lines.append( QLineF(point.x(), yMin, point.x(), yMax) );
 	} else { //vertical axis
 		double xMin = plot->xMin();
 		double xMax = plot->xMax();
 
 		for (const auto point: logicalMinorTickPoints)
 			lines.append( QLineF(xMin, point.y(), xMax, point.y()) );
 	}
 
 	lines = cSystem->mapLogicalToScene(lines, AbstractCoordinateSystem::SuppressPageClipping);
 	for (const auto& line : lines) {
 		minorGridPath.moveTo(line.p1());
 		minorGridPath.lineTo(line.p2());
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 /*!
  * called when the opacity of the grid was changes, update the grid graphics item
  */
 //TODO: this function is only needed for loaded projects where update() doesn't seem to be enough
 //and we have to call gridItem->update() explicitly.
 //This is not required for newly created plots/axes. Why is this difference?
 void AxisPrivate::updateGrid() {
 	gridItem->update();
 }
 
 void AxisPrivate::recalcShapeAndBoundingRect() {
 	if (m_suppressRecalc)
 		return;
 
 	prepareGeometryChange();
 
 	if (linePath.isEmpty()) {
 		axisShape = QPainterPath();
 		boundingRectangle = QRectF();
 		title->setPositionInvalid(true);
 		if (plot) plot->prepareGeometryChange();
 		return;
 	} else {
 		title->setPositionInvalid(false);
 	}
 
 	axisShape = WorksheetElement::shapeFromPath(linePath, linePen);
 	axisShape.addPath(WorksheetElement::shapeFromPath(arrowPath, linePen));
 	axisShape.addPath(WorksheetElement::shapeFromPath(majorTicksPath, majorTicksPen));
 	axisShape.addPath(WorksheetElement::shapeFromPath(minorTicksPath, minorTicksPen));
 
 	QPainterPath  tickLabelsPath = QPainterPath();
 	if (labelsPosition != Axis::NoLabels) {
 		QTransform trafo;
 		QPainterPath tempPath;
 		QFontMetrics fm(labelsFont);
 		QTextDocument td;
 		td.setDefaultFont(labelsFont);
 		for (int i = 0; i < tickLabelPoints.size(); i++) {
 			tempPath = QPainterPath();
 			if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 				tempPath.addRect(fm.boundingRect(tickLabelStrings.at(i)));
 			} else {
 				td.setHtml(tickLabelStrings.at(i));
 				tempPath.addRect(QRectF(0, -td.size().height(), td.size().width(), td.size().height()));
 			}
 
 			trafo.reset();
 			trafo.translate( tickLabelPoints.at(i).x(), tickLabelPoints.at(i).y() );
 
 			trafo.rotate(-labelsRotationAngle);
 			tempPath = trafo.map(tempPath);
 
 			tickLabelsPath.addPath(WorksheetElement::shapeFromPath(tempPath, linePen));
 		}
 		axisShape.addPath(WorksheetElement::shapeFromPath(tickLabelsPath, QPen()));
 	}
 
 	//add title label, if available
 	if ( title->isVisible() && !title->text().text.isEmpty() ) {
 		const QRectF& titleRect = title->graphicsItem()->boundingRect();
 		if (titleRect.width() != 0.0 &&  titleRect.height() != 0.0) {
 			//determine the new position of the title label:
 			//we calculate the new position here and not in retransform(),
 			//since it depends on the size and position of the tick labels, tickLabelsPath, available here.
 			QRectF rect = linePath.boundingRect();
 			qreal offsetX = titleOffsetX; //the distance to the axis line
 			qreal offsetY = titleOffsetY; //the distance to the axis line
 			if (orientation == Axis::AxisHorizontal) {
 				offsetY -= titleRect.height()/2;
 				if (labelsPosition == Axis::LabelsOut)
 					offsetY -= labelsOffset + tickLabelsPath.boundingRect().height();
 				title->setPosition( QPointF( (rect.topLeft().x() + rect.topRight().x())/2 + titleOffsetX, rect.bottomLeft().y() - offsetY ) );
 			} else {
 				offsetX -= titleRect.width()/2;
 				if (labelsPosition == Axis::LabelsOut)
 					offsetX -= labelsOffset+ tickLabelsPath.boundingRect().width();
 				title->setPosition( QPointF( rect.topLeft().x() + offsetX, (rect.topLeft().y() + rect.bottomLeft().y())/2 - titleOffsetY) );
 			}
 			axisShape.addPath(WorksheetElement::shapeFromPath(title->graphicsItem()->mapToParent(title->graphicsItem()->shape()), linePen));
 		}
 	}
 
 	boundingRectangle = axisShape.boundingRect();
 
 	//if the axis goes beyond the current bounding box of the plot (too high offset is used, too long labels etc.)
 	//request a prepareGeometryChange() for the plot in order to properly keep track of geometry changes
 	if (plot)
 		plot->prepareGeometryChange();
 }
 
 /*!
 	paints the content of the axis. Reimplemented from \c QGraphicsItem.
 	\sa QGraphicsItem::paint()
  */
 void AxisPrivate::paint(QPainter *painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	if (!isVisible())
 		return;
 
 	if (linePath.isEmpty())
 		return;
 
 	//draw the line
 	if (linePen.style() != Qt::NoPen) {
 		painter->setOpacity(lineOpacity);
 		painter->setPen(linePen);
 		painter->setBrush(Qt::SolidPattern);
 		painter->drawPath(linePath);
 
 		//draw the arrow
 		if (arrowType != Axis::NoArrow)
 			painter->drawPath(arrowPath);
 	}
 
 	//draw the major ticks
 	if (majorTicksDirection != Axis::noTicks) {
 		painter->setOpacity(majorTicksOpacity);
 		painter->setPen(majorTicksPen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(majorTicksPath);
 	}
 
 	//draw the minor ticks
 	if (minorTicksDirection != Axis::noTicks) {
 		painter->setOpacity(minorTicksOpacity);
 		painter->setPen(minorTicksPen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(minorTicksPath);
 	}
 
 	// draw tick labels
 	if (labelsPosition != Axis::NoLabels) {
 		painter->setOpacity(labelsOpacity);
 		painter->setPen(QPen(labelsColor));
 		painter->setFont(labelsFont);
 		QTextDocument td;
 		td.setDefaultFont(labelsFont);
 		if ((orientation == Axis::AxisHorizontal && plot->xRangeFormat() == CartesianPlot::Numeric) ||
 				(orientation == Axis::AxisVertical && plot->yRangeFormat() == CartesianPlot::Numeric)) {
 			for (int i = 0; i < tickLabelPoints.size(); i++) {
 				painter->translate(tickLabelPoints.at(i));
 				painter->save();
 				painter->rotate(-labelsRotationAngle);
 
 				if (labelsFormat == Axis::FormatDecimal || labelsFormat == Axis::FormatScientificE) {
 					painter->drawText(QPoint(0,0), tickLabelStrings.at(i));
 				} else {
 					td.setHtml(tickLabelStrings.at(i));
 					painter->translate(0, -td.size().height());
 					td.drawContents(painter);
 				}
 				painter->restore();
 				painter->translate(-tickLabelPoints.at(i));
 			}
 		} else { // datetime
 			for (int i = 0; i < tickLabelPoints.size(); i++) {
 				painter->translate(tickLabelPoints.at(i));
 				painter->save();
 				painter->rotate(-labelsRotationAngle);
 				painter->drawText(QPoint(0,0), tickLabelStrings.at(i));
 				painter->restore();
 				painter->translate(-tickLabelPoints.at(i));
 			}
 		}
 	}
 
 	if (m_hovered && !isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Shadow), 2, Qt::SolidLine));
 		painter->drawPath(axisShape);
 	}
 
 	if (isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Highlight), 2, Qt::SolidLine));
 		painter->drawPath(axisShape);
 	}
 }
 
 void AxisPrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	q->createContextMenu()->exec(event->screenPos());
 }
 
 void AxisPrivate::hoverEnterEvent(QGraphicsSceneHoverEvent*) {
 	if (!isSelected()) {
 		m_hovered = true;
 		emit q->hovered();
 		update(axisShape.boundingRect());
 	}
 }
 
 void AxisPrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent*) {
 	if (m_hovered) {
 		m_hovered = false;
 		emit q->unhovered();
 		update(axisShape.boundingRect());
 	}
 }
 
 void AxisPrivate::setPrinting(bool on) {
 	m_printing = on;
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void Axis::save(QXmlStreamWriter* writer) const{
 	Q_D(const Axis);
 
 	writer->writeStartElement( "axis" );
 	writeBasicAttributes( writer );
 	writeCommentElement( writer );
 
 	//general
 	writer->writeStartElement( "general" );
 	writer->writeAttribute( "autoScale", QString::number(d->autoScale) );
 	writer->writeAttribute( "orientation", QString::number(d->orientation) );
 	writer->writeAttribute( "position", QString::number(d->position) );
 	writer->writeAttribute( "scale", QString::number(d->scale) );
 	writer->writeAttribute( "offset", QString::number(d->offset) );
 	writer->writeAttribute( "start", QString::number(d->start) );
 	writer->writeAttribute( "end", QString::number(d->end) );
 	writer->writeAttribute( "scalingFactor", QString::number(d->scalingFactor) );
 	writer->writeAttribute( "zeroOffset", QString::number(d->zeroOffset) );
 	writer->writeAttribute( "titleOffsetX", QString::number(d->titleOffsetX) );
 	writer->writeAttribute( "titleOffsetY", QString::number(d->titleOffsetY) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//label
 	d->title->save( writer );
 
 	//line
 	writer->writeStartElement( "line" );
 	WRITE_QPEN(d->linePen);
 	writer->writeAttribute( "opacity", QString::number(d->lineOpacity) );
 	writer->writeAttribute( "arrowType", QString::number(d->arrowType) );
 	writer->writeAttribute( "arrowPosition", QString::number(d->arrowPosition) );
 	writer->writeAttribute( "arrowSize", QString::number(d->arrowSize) );
 	writer->writeEndElement();
 
 	//major ticks
 	writer->writeStartElement( "majorTicks" );
 	writer->writeAttribute( "direction", QString::number(d->majorTicksDirection) );
 	writer->writeAttribute( "type", QString::number(d->majorTicksType) );
 	writer->writeAttribute( "number", QString::number(d->majorTicksNumber) );
 	writer->writeAttribute( "increment", QString::number(d->majorTicksSpacing) );
 	WRITE_COLUMN(d->majorTicksColumn, majorTicksColumn);
 	writer->writeAttribute( "length", QString::number(d->majorTicksLength) );
 	WRITE_QPEN(d->majorTicksPen);
 	writer->writeAttribute( "opacity", QString::number(d->majorTicksOpacity) );
 	writer->writeEndElement();
 
 	//minor ticks
 	writer->writeStartElement( "minorTicks" );
 	writer->writeAttribute( "direction", QString::number(d->minorTicksDirection) );
 	writer->writeAttribute( "type", QString::number(d->minorTicksType) );
 	writer->writeAttribute( "number", QString::number(d->minorTicksNumber) );
 	writer->writeAttribute( "increment", QString::number(d->minorTicksIncrement) );
 	WRITE_COLUMN(d->minorTicksColumn, minorTicksColumn);
 	writer->writeAttribute( "length", QString::number(d->minorTicksLength) );
 	WRITE_QPEN(d->minorTicksPen);
 	writer->writeAttribute( "opacity", QString::number(d->minorTicksOpacity) );
 	writer->writeEndElement();
 
 	//extra ticks
 
 	//labels
 	writer->writeStartElement( "labels" );
 	writer->writeAttribute( "position", QString::number(d->labelsPosition) );
 	writer->writeAttribute( "offset", QString::number(d->labelsOffset) );
 	writer->writeAttribute( "rotation", QString::number(d->labelsRotationAngle) );
 	writer->writeAttribute( "format", QString::number(d->labelsFormat) );
 	writer->writeAttribute( "precision", QString::number(d->labelsPrecision) );
 	writer->writeAttribute( "autoPrecision", QString::number(d->labelsAutoPrecision) );
 	writer->writeAttribute( "dateTimeFormat", d->labelsDateTimeFormat );
 	WRITE_QCOLOR(d->labelsColor);
 	WRITE_QFONT(d->labelsFont);
 	writer->writeAttribute( "prefix", d->labelsPrefix );
 	writer->writeAttribute( "suffix", d->labelsSuffix );
 	writer->writeAttribute( "opacity", QString::number(d->labelsOpacity) );
 	writer->writeEndElement();
 
 	//grid
 	writer->writeStartElement( "majorGrid" );
 	WRITE_QPEN(d->majorGridPen);
 	writer->writeAttribute( "opacity", QString::number(d->majorGridOpacity) );
 	writer->writeEndElement();
 
 	writer->writeStartElement( "minorGrid" );
 	WRITE_QPEN(d->minorGridPen);
 	writer->writeAttribute( "opacity", QString::number(d->minorGridOpacity) );
 	writer->writeEndElement();
 
 	writer->writeEndElement(); // close "axis" section
 }
 
 //! Load from XML
 bool Axis::load(XmlStreamReader* reader, bool preview) {
 	Q_D(Axis);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "axis")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (!preview && reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (!preview && reader->name() == "general") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("autoScale", autoScale, bool);
 			READ_INT_VALUE("orientation", orientation, Axis::AxisOrientation);
 			READ_INT_VALUE("position", position, Axis::AxisPosition);
 			READ_INT_VALUE("scale", scale, Axis::AxisScale);
 			READ_DOUBLE_VALUE("offset", offset);
 			READ_DOUBLE_VALUE("start", start);
 			READ_DOUBLE_VALUE("end", end);
 			READ_DOUBLE_VALUE("scalingFactor", scalingFactor);
 			READ_DOUBLE_VALUE("zeroOffset", zeroOffset);
 			READ_DOUBLE_VALUE("titleOffsetX", titleOffsetX);
 			READ_DOUBLE_VALUE("titleOffsetY", titleOffsetY);
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (reader->name() == "textLabel") {
 			d->title->load(reader, preview);
 		} else if (!preview && reader->name() == "line") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->linePen);
 			READ_DOUBLE_VALUE("opacity", lineOpacity);
 			READ_INT_VALUE("arrowType", arrowType, Axis::ArrowType);
 			READ_INT_VALUE("arrowPosition", arrowPosition, Axis::ArrowPosition);
 			READ_DOUBLE_VALUE("arrowSize", arrowSize);
 		} else if (!preview && reader->name() == "majorTicks") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("direction", majorTicksDirection, Axis::TicksDirection);
 			READ_INT_VALUE("type", majorTicksType, Axis::TicksType);
 			READ_INT_VALUE("number", majorTicksNumber, int);
 			READ_DOUBLE_VALUE("increment", majorTicksSpacing);
 			READ_COLUMN(majorTicksColumn);
 			READ_DOUBLE_VALUE("length", majorTicksLength);
 			READ_QPEN(d->majorTicksPen);
 			READ_DOUBLE_VALUE("opacity", majorTicksOpacity);
 		} else if (!preview && reader->name() == "minorTicks") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("direction", minorTicksDirection, Axis::TicksDirection);
 			READ_INT_VALUE("type", minorTicksType, Axis::TicksType);
 			READ_INT_VALUE("number", minorTicksNumber, int);
 			READ_DOUBLE_VALUE("increment", minorTicksIncrement);
 			READ_COLUMN(minorTicksColumn);
 			READ_DOUBLE_VALUE("length", minorTicksLength);
 			READ_QPEN(d->minorTicksPen);
 			READ_DOUBLE_VALUE("opacity", minorTicksOpacity);
 		} else if (!preview && reader->name() == "labels") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("position", labelsPosition, Axis::LabelsPosition);
 			READ_DOUBLE_VALUE("offset", labelsOffset);
 			READ_DOUBLE_VALUE("rotation", labelsRotationAngle);
 			READ_INT_VALUE("format", labelsFormat, Axis::LabelsFormat);
 			READ_INT_VALUE("precision", labelsPrecision, int);
 			READ_INT_VALUE("autoPrecision", labelsAutoPrecision, bool);
 			d->labelsDateTimeFormat = attribs.value("dateTimeFormat").toString();
 			READ_QCOLOR(d->labelsColor);
 			READ_QFONT(d->labelsFont);
 
 			//don't produce any warning if no prefix or suffix is set (empty string is allowed here in xml)
 			d->labelsPrefix = attribs.value("prefix").toString();
 			d->labelsSuffix = attribs.value("suffix").toString();
 
 			READ_DOUBLE_VALUE("opacity", labelsOpacity);
 		} else if (!preview && reader->name() == "majorGrid") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->majorGridPen);
 			READ_DOUBLE_VALUE("opacity", majorGridOpacity);
 		} else if (!preview && reader->name() == "minorGrid") {
 			attribs = reader->attributes();
 
 			READ_QPEN(d->minorGridPen);
 			READ_DOUBLE_VALUE("opacity", minorGridOpacity);
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void Axis::loadThemeConfig(const KConfig& config) {
 	const KConfigGroup group = config.group("Axis");
 
 	//we don't want to show the major and minor grid lines for non-first horizontal/vertical axes
 	//determine the index of the axis among other axes having the same orientation
 	bool firstAxis = true;
 	for (const auto* axis : parentAspect()->children<Axis>()) {
 		if (orientation() == axis->orientation()) {
 			if (axis == this) {
 				break;
 			} else {
 				firstAxis = false;
 				break;
 			}
 		}
 	}
 
 	QPen p;
 	// Tick label
-	this->setLabelsColor(group.readEntry("LabelsFontColor",(QColor) this->labelsColor()));
-	this->setLabelsOpacity(group.readEntry("LabelsOpacity",this->labelsOpacity()));
+	this->setLabelsColor(group.readEntry("LabelsFontColor", QColor(Qt::black)));
+	this->setLabelsOpacity(group.readEntry("LabelsOpacity", 1.0));
 
 	//Line
-	this->setLineOpacity(group.readEntry("LineOpacity",this->lineOpacity()));
+	this->setLineOpacity(group.readEntry("LineOpacity", 1.0));
 	p.setColor(group.readEntry("LineColor", (QColor) this->linePen().color()));
 	p.setStyle((Qt::PenStyle)group.readEntry("LineStyle",(int) this->linePen().style()));
 	p.setWidthF(group.readEntry("LineWidth", this->linePen().widthF()));
 	this->setLinePen(p);
 
-	//Major ticks
-	this->setMajorGridOpacity(group.readEntry("MajorGridOpacity", this->majorGridOpacity()));
-	p.setColor(group.readEntry("MajorGridColor",(QColor) this->majorGridPen().color()));
+	//Major grid
 	if (firstAxis)
-		p.setStyle((Qt::PenStyle)group.readEntry("MajorGridStyle",(int) this->majorGridPen().style()));
+		p.setStyle((Qt::PenStyle)group.readEntry("MajorGridStyle", (int)Qt::NoPen));
 	else
 		p.setStyle(Qt::NoPen);
-	p.setWidthF(group.readEntry("MajorGridWidth", this->majorGridPen().widthF()));
+	p.setColor(group.readEntry("MajorGridColor",QColor(Qt::gray)));
+	p.setWidthF(group.readEntry("MajorGridWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	this->setMajorGridPen(p);
-	p.setColor(group.readEntry("MajorTicksColor",(QColor)this->majorTicksPen().color()));
-	p.setStyle((Qt::PenStyle)group.readEntry("MajorTicksLineStyle",(int) this->majorTicksPen().style()));
-	p.setWidthF(group.readEntry("MajorTicksWidth", this->majorTicksPen().widthF()));
+	this->setMajorGridOpacity(group.readEntry("MajorGridOpacity", 1.0));
+
+	//Major ticks
+	p.setStyle((Qt::PenStyle)group.readEntry("MajorTicksLineStyle", (int)Qt::SolidLine));
+	p.setColor(group.readEntry("MajorTicksColor", QColor(Qt::black)));
+	p.setWidthF(group.readEntry("MajorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	this->setMajorTicksPen(p);
-	this->setMajorTicksOpacity(group.readEntry("MajorTicksOpacity",this->majorTicksOpacity()));
+	this->setMajorTicksOpacity(group.readEntry("MajorTicksOpacity", 1.0));
 
-	//Minor ticks
-	this->setMinorGridOpacity(group.readEntry("MinorGridOpacity", this->minorGridOpacity()));
-	p.setColor(group.readEntry("MinorGridColor",(QColor) this->minorGridPen().color()));
+	//Minor grid
 	if (firstAxis)
-		p.setStyle((Qt::PenStyle)group.readEntry("MinorGridStyle",(int) this->minorGridPen().style()));
+		p.setStyle((Qt::PenStyle)group.readEntry("MinorGridStyle", (int)Qt::NoPen));
 	else
 		p.setStyle(Qt::NoPen);
-	p.setWidthF(group.readEntry("MinorGridWidth", this->minorGridPen().widthF()));
+	p.setColor(group.readEntry("MinorGridColor", QColor(Qt::gray)));
+	p.setWidthF(group.readEntry("MinorGridWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
+	this->setMinorGridOpacity(group.readEntry("MinorGridOpacity", 1.0));
 	this->setMinorGridPen(p);
-	p.setColor(group.readEntry("MinorTicksColor",(QColor) this->minorTicksPen().color()));
-	p.setWidthF(group.readEntry("MinorTicksWidth", this->minorTicksPen().widthF()));
+
+	//Minor ticks
+	p.setStyle((Qt::PenStyle)group.readEntry("MinorTicksLineStyle", (int)Qt::SolidLine));
+	p.setColor(group.readEntry("MinorTicksColor", QColor(Qt::black)));
+	p.setWidthF(group.readEntry("MinorTicksWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	this->setMinorTicksPen(p);
-	this->setMinorTicksOpacity(group.readEntry("MinorTicksOpacity",this->minorTicksOpacity()));
+	this->setMinorTicksOpacity(group.readEntry("MinorTicksOpacity", 1.0));
 
 	const QVector<TextLabel*>& childElements = children<TextLabel>(AbstractAspect::ChildIndexFlag::IncludeHidden);
 	for (auto* child : childElements)
 		child->loadThemeConfig(config);
 }
 
 void Axis::saveThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("Axis");
 
 	// Tick label
 	group.writeEntry("LabelsFontColor", (QColor) this->labelsColor());
 	group.writeEntry("LabelsOpacity", this->labelsOpacity());
 
 	//Line
 	group.writeEntry("LineOpacity", this->lineOpacity());
 	group.writeEntry("LineColor", (QColor) this->linePen().color());
 	group.writeEntry("LineStyle", (int) this->linePen().style());
 	group.writeEntry("LineWidth", this->linePen().widthF());
 
 	//Major ticks
 	group.writeEntry("MajorGridOpacity", this->majorGridOpacity());
 	group.writeEntry("MajorGridColor", (QColor) this->majorGridPen().color());
 	group.writeEntry("MajorGridStyle", (int) this->majorGridPen().style());
 	group.writeEntry("MajorGridWidth", this->majorGridPen().widthF());
 	group.writeEntry("MajorTicksColor", (QColor)this->majorTicksPen().color());
 	group.writeEntry("MajorTicksLineStyle", (int) this->majorTicksPen().style());
 	group.writeEntry("MajorTicksWidth", this->majorTicksPen().widthF());
 	group.writeEntry("MajorTicksOpacity", this->majorTicksOpacity());
 	group.writeEntry("MajorTicksType", (int)this->majorTicksType());
 
 	//Minor ticks
 	group.writeEntry("MinorGridOpacity", this->minorGridOpacity());
 	group.writeEntry("MinorGridColor",(QColor) this->minorGridPen().color());
 	group.writeEntry("MinorGridStyle", (int) this->minorGridPen().style());
 	group.writeEntry("MinorGridWidth", this->minorGridPen().widthF());
 	group.writeEntry("MinorTicksColor", (QColor) this->minorTicksPen().color());
 	group.writeEntry("MinorTicksLineStyle",( int) this->minorTicksPen().style());
 	group.writeEntry("MinorTicksWidth", this->minorTicksPen().widthF());
 	group.writeEntry("MinorTicksOpacity", this->minorTicksOpacity());
 	group.writeEntry("MinorTicksType", (int)this->minorTicksType());
 
 	const QVector<TextLabel*>& childElements = children<TextLabel>(AbstractAspect::ChildIndexFlag::IncludeHidden);
 	childElements.at(0)->saveThemeConfig(config);
 }
diff --git a/src/backend/worksheet/plots/cartesian/XYCurve.cpp b/src/backend/worksheet/plots/cartesian/XYCurve.cpp
index cce267aa5..9e5eb5187 100644
--- a/src/backend/worksheet/plots/cartesian/XYCurve.cpp
+++ b/src/backend/worksheet/plots/cartesian/XYCurve.cpp
@@ -1,3331 +1,3333 @@
 /***************************************************************************
     File                 : XYCurve.cpp
     Project              : LabPlot
     Description          : A xy-curve
     --------------------------------------------------------------------
     Copyright            : (C) 2010-2020 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2013-2020 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                                           *
  *                                                                         *
  ***************************************************************************/
 
 /*!
   \class XYCurve
   \brief A 2D-curve, provides an interface for editing many properties of the curve.
 
   \ingroup worksheet
 */
 
 #include "XYCurve.h"
 #include "XYCurvePrivate.h"
 #include "backend/core/column/Column.h"
 #include "backend/worksheet/plots/cartesian/CartesianCoordinateSystem.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/core/Project.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/macros.h"
 #include "backend/lib/trace.h"
 #include "backend/gsl/errors.h"
 #include "tools/ImageTools.h"
 
 #include <QPainter>
 #include <QGraphicsSceneContextMenuEvent>
 #include <QMenu>
 #include <QDesktopWidget>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 extern "C" {
 #include <gsl/gsl_spline.h>
 #include <gsl/gsl_errno.h>
 }
 
 XYCurve::XYCurve(const QString &name, AspectType type)
 	: WorksheetElement(name, type), d_ptr(new XYCurvePrivate(this)) {
 
 	init();
 }
 
 XYCurve::XYCurve(const QString& name, XYCurvePrivate* dd, AspectType type)
 	: WorksheetElement(name, type), d_ptr(dd) {
 
 	init();
 }
 
 //no need to delete the d-pointer here - it inherits from QGraphicsItem
 //and is deleted during the cleanup in QGraphicsScene
 XYCurve::~XYCurve() = default;
 
 void XYCurve::finalizeAdd() {
 	Q_D(XYCurve);
 	d->plot = static_cast<const CartesianPlot*>(parentAspect());
 	d->cSystem = static_cast<const CartesianCoordinateSystem*>(d->plot->coordinateSystem());
 }
 
 void XYCurve::init() {
 	Q_D(XYCurve);
 
 	KConfig config;
 	KConfigGroup group = config.group("XYCurve");
 
 	d->lineType = (XYCurve::LineType) group.readEntry("LineType", (int)XYCurve::Line);
 	d->lineIncreasingXOnly = group.readEntry("LineIncreasingXOnly", false);
 	d->lineSkipGaps = group.readEntry("SkipLineGaps", false);
 	d->lineInterpolationPointsCount = group.readEntry("LineInterpolationPointsCount", 1);
 	d->linePen.setStyle( (Qt::PenStyle) group.readEntry("LineStyle", (int)Qt::SolidLine) );
 	d->linePen.setColor( group.readEntry("LineColor", QColor(Qt::black)) );
 	d->linePen.setWidthF( group.readEntry("LineWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)) );
 	d->lineOpacity = group.readEntry("LineOpacity", 1.0);
 
 	d->dropLineType = (XYCurve::DropLineType) group.readEntry("DropLineType", (int)XYCurve::NoLine);
 	d->dropLinePen.setStyle( (Qt::PenStyle) group.readEntry("DropLineStyle", (int)Qt::SolidLine) );
 	d->dropLinePen.setColor( group.readEntry("DropLineColor", QColor(Qt::black)));
 	d->dropLinePen.setWidthF( group.readEntry("DropLineWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)) );
 	d->dropLineOpacity = group.readEntry("DropLineOpacity", 1.0);
 
 	d->symbolsStyle = (Symbol::Style)group.readEntry("SymbolStyle", (int)Symbol::NoSymbols);
 	d->symbolsSize = group.readEntry("SymbolSize", Worksheet::convertToSceneUnits(5, Worksheet::Point));
 	d->symbolsRotationAngle = group.readEntry("SymbolRotation", 0.0);
 	d->symbolsOpacity = group.readEntry("SymbolOpacity", 1.0);
 	d->symbolsBrush.setStyle( (Qt::BrushStyle)group.readEntry("SymbolFillingStyle", (int)Qt::SolidPattern) );
 	d->symbolsBrush.setColor( group.readEntry("SymbolFillingColor", QColor(Qt::black)) );
 	d->symbolsPen.setStyle( (Qt::PenStyle)group.readEntry("SymbolBorderStyle", (int)Qt::SolidLine) );
 	d->symbolsPen.setColor( group.readEntry("SymbolBorderColor", QColor(Qt::black)) );
 	d->symbolsPen.setWidthF( group.readEntry("SymbolBorderWidth", Worksheet::convertToSceneUnits(0.0, Worksheet::Point)) );
 
 	d->valuesType = (XYCurve::ValuesType) group.readEntry("ValuesType", (int)XYCurve::NoValues);
 	d->valuesPosition = (XYCurve::ValuesPosition) group.readEntry("ValuesPosition", (int)XYCurve::ValuesAbove);
 	d->valuesDistance = group.readEntry("ValuesDistance", Worksheet::convertToSceneUnits(5, Worksheet::Point));
 	d->valuesRotationAngle = group.readEntry("ValuesRotation", 0.0);
 	d->valuesOpacity = group.readEntry("ValuesOpacity", 1.0);
 	d->valuesNumericFormat = group.readEntry("ValuesNumericFormat", "f").at(0).toLatin1();
 	d->valuesPrecision = group.readEntry("ValuesNumericFormat", 2);
 	d->valuesDateTimeFormat = group.readEntry("ValuesDateTimeFormat", "yyyy-MM-dd");
 	d->valuesPrefix = group.readEntry("ValuesPrefix", "");
 	d->valuesSuffix = group.readEntry("ValuesSuffix", "");
 	d->valuesFont = group.readEntry("ValuesFont", QFont());
 	d->valuesFont.setPixelSize( Worksheet::convertToSceneUnits( 8, Worksheet::Point ) );
 	d->valuesColor = group.readEntry("ValuesColor", QColor(Qt::black));
 
 	d->fillingPosition = (XYCurve::FillingPosition) group.readEntry("FillingPosition", (int)XYCurve::NoFilling);
 	d->fillingType = (PlotArea::BackgroundType) group.readEntry("FillingType", (int)PlotArea::Color);
 	d->fillingColorStyle = (PlotArea::BackgroundColorStyle) group.readEntry("FillingColorStyle", (int) PlotArea::SingleColor);
 	d->fillingImageStyle = (PlotArea::BackgroundImageStyle) group.readEntry("FillingImageStyle", (int) PlotArea::Scaled);
 	d->fillingBrushStyle = (Qt::BrushStyle) group.readEntry("FillingBrushStyle", (int) Qt::SolidPattern);
 	d->fillingFileName = group.readEntry("FillingFileName", QString());
 	d->fillingFirstColor = group.readEntry("FillingFirstColor", QColor(Qt::white));
 	d->fillingSecondColor = group.readEntry("FillingSecondColor", QColor(Qt::black));
 	d->fillingOpacity = group.readEntry("FillingOpacity", 1.0);
 
 	d->xErrorType = (XYCurve::ErrorType) group.readEntry("XErrorType", (int)XYCurve::NoError);
 	d->yErrorType = (XYCurve::ErrorType) group.readEntry("YErrorType", (int)XYCurve::NoError);
 	d->errorBarsType = (XYCurve::ErrorBarsType) group.readEntry("ErrorBarsType", (int)XYCurve::ErrorBarsSimple);
 	d->errorBarsCapSize = group.readEntry( "ErrorBarsCapSize", Worksheet::convertToSceneUnits(10, Worksheet::Point) );
 	d->errorBarsPen.setStyle( (Qt::PenStyle)group.readEntry("ErrorBarsStyle", (int)Qt::SolidLine) );
 	d->errorBarsPen.setColor( group.readEntry("ErrorBarsColor", QColor(Qt::black)) );
 	d->errorBarsPen.setWidthF( group.readEntry("ErrorBarsWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)) );
 	d->errorBarsOpacity = group.readEntry("ErrorBarsOpacity", 1.0);
 }
 
 void XYCurve::initActions() {
 	visibilityAction = new QAction(QIcon::fromTheme("view-visible"), i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, SIGNAL(triggered(bool)), this, SLOT(visibilityChanged()));
 
 	navigateToAction = new QAction(QIcon::fromTheme("go-next-view"), QString(), this);
 	connect(navigateToAction, SIGNAL(triggered(bool)), this, SLOT(navigateTo()));
 
 	m_menusInitialized = true;
 }
 
 QMenu* XYCurve::createContextMenu() {
 	if (!m_menusInitialized)
 		initActions();
 
 	QMenu* menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1); //skip the first action because of the "title-action"
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 
 	//"data analysis" menu
 	auto* plot = static_cast<CartesianPlot*>(parentAspect());
 	menu->insertMenu(visibilityAction, plot->analysisMenu());
 	menu->insertSeparator(visibilityAction);
 
 	//"Navigate to spreadsheet"-action, show only if x- or y-columns have data from a spreadsheet
 	AbstractAspect* parentSpreadsheet = nullptr;
 	if (xColumn() && dynamic_cast<Spreadsheet*>(xColumn()->parentAspect()) )
 		parentSpreadsheet = xColumn()->parentAspect();
 	else if (yColumn() && dynamic_cast<Spreadsheet*>(yColumn()->parentAspect()) )
 		parentSpreadsheet = yColumn()->parentAspect();
 
 	if (parentSpreadsheet) {
 		navigateToAction->setText(i18n("Navigate to \"%1\"", parentSpreadsheet->name()));
 		navigateToAction->setData(parentSpreadsheet->path());
 		menu->insertAction(visibilityAction, navigateToAction);
 		menu->insertSeparator(visibilityAction);
 	}
 
 	//if the context menu is called on an item that is not selected yet, select it
 	if (!graphicsItem()->isSelected())
 		graphicsItem()->setSelected(true);
 
 	return menu;
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon XYCurve::icon() const {
 	return QIcon::fromTheme("labplot-xy-curve");
 }
 
 QGraphicsItem* XYCurve::graphicsItem() const {
 	return d_ptr;
 }
 
 STD_SWAP_METHOD_SETTER_CMD_IMPL(XYCurve, SetVisible, bool, swapVisible)
 void XYCurve::setVisible(bool on) {
 	Q_D(XYCurve);
 	exec(new XYCurveSetVisibleCmd(d, on, on ? ki18n("%1: set visible") : ki18n("%1: set invisible")));
 }
 
 bool XYCurve::isVisible() const {
 	Q_D(const XYCurve);
 	return d->isVisible();
 }
 
 void XYCurve::setPrinting(bool on) {
 	Q_D(XYCurve);
 	d->setPrinting(on);
 }
 
 //##############################################################################
 //##########################  getter methods  ##################################
 //##############################################################################
 
 //data source
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, xColumn, xColumn)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, yColumn, yColumn)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, xColumnPath, xColumnPath)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, yColumnPath, yColumnPath)
 
 //line
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::LineType, lineType, lineType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, bool, lineSkipGaps, lineSkipGaps)
 BASIC_SHARED_D_READER_IMPL(XYCurve, bool, lineIncreasingXOnly, lineIncreasingXOnly)
 BASIC_SHARED_D_READER_IMPL(XYCurve, int, lineInterpolationPointsCount, lineInterpolationPointsCount)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QPen, linePen, linePen)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, lineOpacity, lineOpacity)
 
 //droplines
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::DropLineType, dropLineType, dropLineType)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QPen, dropLinePen, dropLinePen)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, dropLineOpacity, dropLineOpacity)
 
 //symbols
 BASIC_SHARED_D_READER_IMPL(XYCurve, Symbol::Style, symbolsStyle, symbolsStyle)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, symbolsOpacity, symbolsOpacity)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, symbolsRotationAngle, symbolsRotationAngle)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, symbolsSize, symbolsSize)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QBrush, symbolsBrush, symbolsBrush)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QPen, symbolsPen, symbolsPen)
 
 //values
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::ValuesType, valuesType, valuesType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn *, valuesColumn, valuesColumn)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, valuesColumnPath, valuesColumnPath)
 
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::ValuesPosition, valuesPosition, valuesPosition)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, valuesDistance, valuesDistance)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, valuesRotationAngle, valuesRotationAngle)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, valuesOpacity, valuesOpacity)
 CLASS_SHARED_D_READER_IMPL(XYCurve, char, valuesNumericFormat, valuesNumericFormat)
 BASIC_SHARED_D_READER_IMPL(XYCurve, int, valuesPrecision, valuesPrecision)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, valuesDateTimeFormat, valuesDateTimeFormat)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, valuesPrefix, valuesPrefix)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, valuesSuffix, valuesSuffix)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QColor, valuesColor, valuesColor)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QFont, valuesFont, valuesFont)
 
 //filling
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::FillingPosition, fillingPosition, fillingPosition)
 BASIC_SHARED_D_READER_IMPL(XYCurve, PlotArea::BackgroundType, fillingType, fillingType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, PlotArea::BackgroundColorStyle, fillingColorStyle, fillingColorStyle)
 BASIC_SHARED_D_READER_IMPL(XYCurve, PlotArea::BackgroundImageStyle, fillingImageStyle, fillingImageStyle)
 CLASS_SHARED_D_READER_IMPL(XYCurve, Qt::BrushStyle, fillingBrushStyle, fillingBrushStyle)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QColor, fillingFirstColor, fillingFirstColor)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QColor, fillingSecondColor, fillingSecondColor)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, fillingFileName, fillingFileName)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, fillingOpacity, fillingOpacity)
 
 //error bars
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::ErrorType, xErrorType, xErrorType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, xErrorPlusColumn, xErrorPlusColumn)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, xErrorMinusColumn, xErrorMinusColumn)
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::ErrorType, yErrorType, yErrorType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, yErrorPlusColumn, yErrorPlusColumn)
 BASIC_SHARED_D_READER_IMPL(XYCurve, const AbstractColumn*, yErrorMinusColumn, yErrorMinusColumn)
 
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, xErrorPlusColumnPath, xErrorPlusColumnPath)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, xErrorMinusColumnPath, xErrorMinusColumnPath)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, yErrorPlusColumnPath, yErrorPlusColumnPath)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QString, yErrorMinusColumnPath, yErrorMinusColumnPath)
 
 BASIC_SHARED_D_READER_IMPL(XYCurve, XYCurve::ErrorBarsType, errorBarsType, errorBarsType)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, errorBarsCapSize, errorBarsCapSize)
 CLASS_SHARED_D_READER_IMPL(XYCurve, QPen, errorBarsPen, errorBarsPen)
 BASIC_SHARED_D_READER_IMPL(XYCurve, qreal, errorBarsOpacity, errorBarsOpacity)
 
 /*!
  * return \c true if the data in the source columns (x, y) used in the analysis curves, \c false otherwise
  */
 bool XYCurve::isSourceDataChangedSinceLastRecalc() const {
 	Q_D(const XYCurve);
 	return d->sourceDataChangedSinceLastRecalc;
 }
 
 //##############################################################################
 //#################  setter methods and undo commands ##########################
 //##############################################################################
 
 // 1) add XYCurveSetXColumnCmd as friend class to XYCurve
 // 2) add XYCURVE_COLUMN_CONNECT(x) as private method to XYCurve
 // 3) define all missing slots
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(X, x, recalcLogicalPoints)
 void XYCurve::setXColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->xColumn)
 		exec(new XYCurveSetXColumnCmd(d, column, ki18n("%1: x-data source changed")));
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(Y, y, recalcLogicalPoints)
 void XYCurve::setYColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->yColumn)
 		exec(new XYCurveSetYColumnCmd(d, column, ki18n("%1: y-data source changed")));
 }
 
 void XYCurve::setXColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->xColumnPath = path;
 }
 
 void XYCurve::setYColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->yColumnPath = path;
 }
 
 //Line
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLineType, XYCurve::LineType, lineType, updateLines)
 void XYCurve::setLineType(LineType type) {
 	Q_D(XYCurve);
 	if (type != d->lineType)
 		exec(new XYCurveSetLineTypeCmd(d, type, ki18n("%1: line type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLineSkipGaps, bool, lineSkipGaps, updateLines)
 void XYCurve::setLineSkipGaps(bool skip) {
 	Q_D(XYCurve);
 	if (skip != d->lineSkipGaps)
 		exec(new XYCurveSetLineSkipGapsCmd(d, skip, ki18n("%1: set skip line gaps")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLineIncreasingXOnly, bool, lineIncreasingXOnly, updateLines)
 void XYCurve::setLineIncreasingXOnly(bool incr) {
 	Q_D(XYCurve);
 	if (incr != d->lineIncreasingXOnly)
 		exec(new XYCurveSetLineIncreasingXOnlyCmd(d, incr, ki18n("%1: set increasing X")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLineInterpolationPointsCount, int, lineInterpolationPointsCount, updateLines)
 void XYCurve::setLineInterpolationPointsCount(int count) {
 	Q_D(XYCurve);
 	if (count != d->lineInterpolationPointsCount)
 		exec(new XYCurveSetLineInterpolationPointsCountCmd(d, count, ki18n("%1: set the number of interpolation points")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLinePen, QPen, linePen, recalcShapeAndBoundingRect)
 void XYCurve::setLinePen(const QPen &pen) {
 	Q_D(XYCurve);
 	if (pen != d->linePen)
 		exec(new XYCurveSetLinePenCmd(d, pen, ki18n("%1: set line style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetLineOpacity, qreal, lineOpacity, updatePixmap);
 void XYCurve::setLineOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->lineOpacity)
 		exec(new XYCurveSetLineOpacityCmd(d, opacity, ki18n("%1: set line opacity")));
 }
 
 //Drop lines
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetDropLineType, XYCurve::DropLineType, dropLineType, updateDropLines)
 void XYCurve::setDropLineType(DropLineType type) {
 	Q_D(XYCurve);
 	if (type != d->dropLineType)
 		exec(new XYCurveSetDropLineTypeCmd(d, type, ki18n("%1: drop line type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetDropLinePen, QPen, dropLinePen, recalcShapeAndBoundingRect)
 void XYCurve::setDropLinePen(const QPen &pen) {
 	Q_D(XYCurve);
 	if (pen != d->dropLinePen)
 		exec(new XYCurveSetDropLinePenCmd(d, pen, ki18n("%1: set drop line style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetDropLineOpacity, qreal, dropLineOpacity, updatePixmap)
 void XYCurve::setDropLineOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->dropLineOpacity)
 		exec(new XYCurveSetDropLineOpacityCmd(d, opacity, ki18n("%1: set drop line opacity")));
 }
 
 // Symbols-Tab
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsStyle, Symbol::Style, symbolsStyle, retransform)
 void XYCurve::setSymbolsStyle(Symbol::Style style) {
 	Q_D(XYCurve);
 	if (style != d->symbolsStyle)
 		exec(new XYCurveSetSymbolsStyleCmd(d, style, ki18n("%1: set symbol style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsSize, qreal, symbolsSize, updateSymbols)
 void XYCurve::setSymbolsSize(qreal size) {
 	Q_D(XYCurve);
 	if (!qFuzzyCompare(1 + size, 1 + d->symbolsSize))
 		exec(new XYCurveSetSymbolsSizeCmd(d, size, ki18n("%1: set symbol size")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsRotationAngle, qreal, symbolsRotationAngle, updateSymbols)
 void XYCurve::setSymbolsRotationAngle(qreal angle) {
 	Q_D(XYCurve);
 	if (!qFuzzyCompare(1 + angle, 1 + d->symbolsRotationAngle))
 		exec(new XYCurveSetSymbolsRotationAngleCmd(d, angle, ki18n("%1: rotate symbols")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsBrush, QBrush, symbolsBrush, updatePixmap)
 void XYCurve::setSymbolsBrush(const QBrush &brush) {
 	Q_D(XYCurve);
 	if (brush != d->symbolsBrush)
 		exec(new XYCurveSetSymbolsBrushCmd(d, brush, ki18n("%1: set symbol filling")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsPen, QPen, symbolsPen, updateSymbols)
 void XYCurve::setSymbolsPen(const QPen &pen) {
 	Q_D(XYCurve);
 	if (pen != d->symbolsPen)
 		exec(new XYCurveSetSymbolsPenCmd(d, pen, ki18n("%1: set symbol outline style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetSymbolsOpacity, qreal, symbolsOpacity, updatePixmap)
 void XYCurve::setSymbolsOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->symbolsOpacity)
 		exec(new XYCurveSetSymbolsOpacityCmd(d, opacity, ki18n("%1: set symbols opacity")));
 }
 
 //Values-Tab
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesType, XYCurve::ValuesType, valuesType, updateValues)
 void XYCurve::setValuesType(XYCurve::ValuesType type) {
 	Q_D(XYCurve);
 	if (type != d->valuesType)
 		exec(new XYCurveSetValuesTypeCmd(d, type, ki18n("%1: set values type")));
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(Values, values, updateValues)
 void XYCurve::setValuesColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->valuesColumn) {
 		exec(new XYCurveSetValuesColumnCmd(d, column, ki18n("%1: set values column")));
 		if (column)
 			connect(column, SIGNAL(dataChanged(const AbstractColumn*)), this, SLOT(updateValues()));
 	}
 }
 
 void XYCurve::setValuesColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->valuesColumnPath = path;
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesPosition, XYCurve::ValuesPosition, valuesPosition, updateValues)
 void XYCurve::setValuesPosition(ValuesPosition position) {
 	Q_D(XYCurve);
 	if (position != d->valuesPosition)
 		exec(new XYCurveSetValuesPositionCmd(d, position, ki18n("%1: set values position")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesDistance, qreal, valuesDistance, updateValues)
 void XYCurve::setValuesDistance(qreal distance) {
 	Q_D(XYCurve);
 	if (distance != d->valuesDistance)
 		exec(new XYCurveSetValuesDistanceCmd(d, distance, ki18n("%1: set values distance")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesRotationAngle, qreal, valuesRotationAngle, updateValues)
 void XYCurve::setValuesRotationAngle(qreal angle) {
 	Q_D(XYCurve);
 	if (!qFuzzyCompare(1 + angle, 1 + d->valuesRotationAngle))
 		exec(new XYCurveSetValuesRotationAngleCmd(d, angle, ki18n("%1: rotate values")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesOpacity, qreal, valuesOpacity, updatePixmap)
 void XYCurve::setValuesOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->valuesOpacity)
 		exec(new XYCurveSetValuesOpacityCmd(d, opacity, ki18n("%1: set values opacity")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesNumericFormat, char, valuesNumericFormat, updateValues)
 void XYCurve::setValuesNumericFormat(char format) {
 	Q_D(XYCurve);
 	if (format != d->valuesNumericFormat)
 		exec(new XYCurveSetValuesNumericFormatCmd(d, format, ki18n("%1: set values numeric format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesPrecision, int, valuesPrecision, updateValues)
 void XYCurve::setValuesPrecision(int precision) {
 	Q_D(XYCurve);
 	if (precision != d->valuesPrecision)
 		exec(new XYCurveSetValuesPrecisionCmd(d, precision, ki18n("%1: set values precision")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesDateTimeFormat, QString, valuesDateTimeFormat, updateValues)
 void XYCurve::setValuesDateTimeFormat(const QString& format) {
 	Q_D(XYCurve);
 	if (format != d->valuesDateTimeFormat)
 		exec(new XYCurveSetValuesDateTimeFormatCmd(d, format, ki18n("%1: set values datetime format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesPrefix, QString, valuesPrefix, updateValues)
 void XYCurve::setValuesPrefix(const QString& prefix) {
 	Q_D(XYCurve);
 	if (prefix != d->valuesPrefix)
 		exec(new XYCurveSetValuesPrefixCmd(d, prefix, ki18n("%1: set values prefix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesSuffix, QString, valuesSuffix, updateValues)
 void XYCurve::setValuesSuffix(const QString& suffix) {
 	Q_D(XYCurve);
 	if (suffix != d->valuesSuffix)
 		exec(new XYCurveSetValuesSuffixCmd(d, suffix, ki18n("%1: set values suffix")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesFont, QFont, valuesFont, updateValues)
 void XYCurve::setValuesFont(const QFont& font) {
 	Q_D(XYCurve);
 	if (font != d->valuesFont)
 		exec(new XYCurveSetValuesFontCmd(d, font, ki18n("%1: set values font")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetValuesColor, QColor, valuesColor, updatePixmap)
 void XYCurve::setValuesColor(const QColor& color) {
 	Q_D(XYCurve);
 	if (color != d->valuesColor)
 		exec(new XYCurveSetValuesColorCmd(d, color, ki18n("%1: set values color")));
 }
 
 //Filling
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingPosition, XYCurve::FillingPosition, fillingPosition, updateFilling)
 void XYCurve::setFillingPosition(FillingPosition position) {
 	Q_D(XYCurve);
 	if (position != d->fillingPosition)
 		exec(new XYCurveSetFillingPositionCmd(d, position, ki18n("%1: filling position changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingType, PlotArea::BackgroundType, fillingType, updatePixmap)
 void XYCurve::setFillingType(PlotArea::BackgroundType type) {
 	Q_D(XYCurve);
 	if (type != d->fillingType)
 		exec(new XYCurveSetFillingTypeCmd(d, type, ki18n("%1: filling type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingColorStyle, PlotArea::BackgroundColorStyle, fillingColorStyle, updatePixmap)
 void XYCurve::setFillingColorStyle(PlotArea::BackgroundColorStyle style) {
 	Q_D(XYCurve);
 	if (style != d->fillingColorStyle)
 		exec(new XYCurveSetFillingColorStyleCmd(d, style, ki18n("%1: filling color style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingImageStyle, PlotArea::BackgroundImageStyle, fillingImageStyle, updatePixmap)
 void XYCurve::setFillingImageStyle(PlotArea::BackgroundImageStyle style) {
 	Q_D(XYCurve);
 	if (style != d->fillingImageStyle)
 		exec(new XYCurveSetFillingImageStyleCmd(d, style, ki18n("%1: filling image style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingBrushStyle, Qt::BrushStyle, fillingBrushStyle, updatePixmap)
 void XYCurve::setFillingBrushStyle(Qt::BrushStyle style) {
 	Q_D(XYCurve);
 	if (style != d->fillingBrushStyle)
 		exec(new XYCurveSetFillingBrushStyleCmd(d, style, ki18n("%1: filling brush style changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingFirstColor, QColor, fillingFirstColor, updatePixmap)
 void XYCurve::setFillingFirstColor(const QColor& color) {
 	Q_D(XYCurve);
 	if (color != d->fillingFirstColor)
 		exec(new XYCurveSetFillingFirstColorCmd(d, color, ki18n("%1: set filling first color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingSecondColor, QColor, fillingSecondColor, updatePixmap)
 void XYCurve::setFillingSecondColor(const QColor& color) {
 	Q_D(XYCurve);
 	if (color != d->fillingSecondColor)
 		exec(new XYCurveSetFillingSecondColorCmd(d, color, ki18n("%1: set filling second color")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingFileName, QString, fillingFileName, updatePixmap)
 void XYCurve::setFillingFileName(const QString& fileName) {
 	Q_D(XYCurve);
 	if (fileName != d->fillingFileName)
 		exec(new XYCurveSetFillingFileNameCmd(d, fileName, ki18n("%1: set filling image")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetFillingOpacity, qreal, fillingOpacity, updatePixmap)
 void XYCurve::setFillingOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->fillingOpacity)
 		exec(new XYCurveSetFillingOpacityCmd(d, opacity, ki18n("%1: set filling opacity")));
 }
 
 //Error bars
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetXErrorType, XYCurve::ErrorType, xErrorType, updateErrorBars)
 void XYCurve::setXErrorType(ErrorType type) {
 	Q_D(XYCurve);
 	if (type != d->xErrorType)
 		exec(new XYCurveSetXErrorTypeCmd(d, type, ki18n("%1: x-error type changed")));
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(XErrorPlus, xErrorPlus, updateErrorBars)
 void XYCurve::setXErrorPlusColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->xErrorPlusColumn) {
 		exec(new XYCurveSetXErrorPlusColumnCmd(d, column, ki18n("%1: set x-error column")));
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &XYCurve::updateErrorBars);
 			//in the macro we connect to recalcLogicalPoints which is not needed for error columns
 			disconnect(column, &AbstractColumn::dataChanged, this, &XYCurve::recalcLogicalPoints);
 		}
 	}
 }
 
 void XYCurve::setXErrorPlusColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->xErrorPlusColumnPath = path;
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(XErrorMinus, xErrorMinus, updateErrorBars)
 void XYCurve::setXErrorMinusColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->xErrorMinusColumn) {
 		exec(new XYCurveSetXErrorMinusColumnCmd(d, column, ki18n("%1: set x-error column")));
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &XYCurve::updateErrorBars);
 			//in the macro we connect to recalcLogicalPoints which is not needed for error columns
 			disconnect(column, &AbstractColumn::dataChanged, this, &XYCurve::recalcLogicalPoints);
 		}
 	}
 }
 
 void XYCurve::setXErrorMinusColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->xErrorMinusColumnPath = path;
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetYErrorType, XYCurve::ErrorType, yErrorType, updateErrorBars)
 void XYCurve::setYErrorType(ErrorType type) {
 	Q_D(XYCurve);
 	if (type != d->yErrorType)
 		exec(new XYCurveSetYErrorTypeCmd(d, type, ki18n("%1: y-error type changed")));
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(YErrorPlus, yErrorPlus, updateErrorBars)
 void XYCurve::setYErrorPlusColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->yErrorPlusColumn) {
 		exec(new XYCurveSetYErrorPlusColumnCmd(d, column, ki18n("%1: set y-error column")));
 		if (column) {
 			connect(column, SIGNAL(dataChanged(const AbstractColumn*)), this, SLOT(updateErrorBars()));
 			//in the macro we connect to recalcLogicalPoints which is not needed for error columns
 			disconnect(column, &AbstractColumn::dataChanged, this, &XYCurve::recalcLogicalPoints);
 		}
 	}
 }
 
 void XYCurve::setYErrorPlusColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->yErrorPlusColumnPath = path;
 }
 
 XYCURVE_COLUMN_SETTER_CMD_IMPL_F_S(YErrorMinus, yErrorMinus, updateErrorBars)
 void XYCurve::setYErrorMinusColumn(const AbstractColumn* column) {
 	Q_D(XYCurve);
 	if (column != d->yErrorMinusColumn) {
 		exec(new XYCurveSetYErrorMinusColumnCmd(d, column, ki18n("%1: set y-error column")));
 		if (column) {
 			connect(column, &AbstractColumn::dataChanged, this, &XYCurve::updateErrorBars);
 			//in the macro we connect to recalcLogicalPoints which is not needed for error columns
 			disconnect(column, &AbstractColumn::dataChanged, this, &XYCurve::recalcLogicalPoints);
 		}
 	}
 }
 
 void XYCurve::setYErrorMinusColumnPath(const QString& path) {
 	Q_D(XYCurve);
 	d->yErrorMinusColumnPath = path;
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetErrorBarsCapSize, qreal, errorBarsCapSize, updateErrorBars)
 void XYCurve::setErrorBarsCapSize(qreal size) {
 	Q_D(XYCurve);
 	if (size != d->errorBarsCapSize)
 		exec(new XYCurveSetErrorBarsCapSizeCmd(d, size, ki18n("%1: set error bar cap size")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetErrorBarsType, XYCurve::ErrorBarsType, errorBarsType, updateErrorBars)
 void XYCurve::setErrorBarsType(ErrorBarsType type) {
 	Q_D(XYCurve);
 	if (type != d->errorBarsType)
 		exec(new XYCurveSetErrorBarsTypeCmd(d, type, ki18n("%1: error bar type changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetErrorBarsPen, QPen, errorBarsPen, recalcShapeAndBoundingRect)
 void XYCurve::setErrorBarsPen(const QPen& pen) {
 	Q_D(XYCurve);
 	if (pen != d->errorBarsPen)
 		exec(new XYCurveSetErrorBarsPenCmd(d, pen, ki18n("%1: set error bar style")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(XYCurve, SetErrorBarsOpacity, qreal, errorBarsOpacity, updatePixmap)
 void XYCurve::setErrorBarsOpacity(qreal opacity) {
 	Q_D(XYCurve);
 	if (opacity != d->errorBarsOpacity)
 		exec(new XYCurveSetErrorBarsOpacityCmd(d, opacity, ki18n("%1: set error bar opacity")));
 }
 
 void XYCurve::suppressRetransform(bool b) {
 	Q_D(XYCurve);
 	d->suppressRetransform(b);
 }
 
 //##############################################################################
 //#################################  SLOTS  ####################################
 //##############################################################################
 void XYCurve::retransform() {
 	Q_D(XYCurve);
 	d->retransform();
 }
 
 void XYCurve::recalcLogicalPoints() {
 	Q_D(XYCurve);
 	d->recalcLogicalPoints();
 }
 
 void XYCurve::updateValues() {
 	Q_D(XYCurve);
 	d->updateValues();
 }
 
 void XYCurve::updateErrorBars() {
 	Q_D(XYCurve);
 	d->updateErrorBars();
 }
 
 //TODO
 void XYCurve::handleResize(double horizontalRatio, double verticalRatio, bool pageResize) {
 	Q_UNUSED(pageResize);
 	Q_D(const XYCurve);
 
 	setSymbolsSize(d->symbolsSize * horizontalRatio);
 
 	QPen pen = d->symbolsPen;
 	pen.setWidthF(pen.widthF() * (horizontalRatio + verticalRatio) / 2.0);
 	setSymbolsPen(pen);
 
 	pen = d->linePen;
 	pen.setWidthF(pen.widthF() * (horizontalRatio + verticalRatio) / 2.0);
 	setLinePen(pen);
 
 	//setValuesDistance(d->distance*);
 	QFont font = d->valuesFont;
 	font.setPointSizeF(font.pointSizeF()*horizontalRatio);
 	setValuesFont(font);
 }
 
 /*!
  * returns \c true if the aspect being removed \c removedAspect is equal to \c column
  * or to one of its parents. returns \c false otherwise.
  */
 bool XYCurve::columnRemoved(const AbstractColumn* column, const AbstractAspect* removedAspect) const {
 	// TODO: BAD HACK.
 	// In macrosXYCurve.h every parent of the column is connected to the function aspectAboutToBeRemoved().
 	// When a column is removed, the function aspectAboutToBeRemoved is called and the column pointer is set to nullptr.
 	// However, when a child of the parent is removed, the parent calls the aspectAboutToBeRemoved() again, but
 	// the column was already disconnected.
 	// Better solution would be to emit aspectAboutToBeRemoved() for every column when their parents are removed.
 	// At the moment this signal is only emitted when the column is deleted directly and not when its parent is deleted.
 	// Once this is done, the connection of all parents to the aspectAboutToBeRemoved() signal can be removed.
 	if (!column)
 		return false;
 
 	bool removed = (removedAspect == column);
 	if (!removed) {
 		auto* parent = column->parentAspect();
 		while (parent) {
 			if (parent == removedAspect) {
 				removed = true;
 				break;
 			}
 			parent = parent->parentAspect();
 		}
 	}
 	return removed;
 }
 
 void XYCurve::xColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->xColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->xColumn = nullptr;
 		d->retransform();
 	}
 }
 
 void XYCurve::yColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->yColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->yColumn = nullptr;
 		d->retransform();
 	}
 }
 
 void XYCurve::valuesColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->valuesColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->valuesColumn = nullptr;
 		d->updateValues();
 	}
 }
 
 void XYCurve::xErrorPlusColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->xErrorPlusColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->xErrorPlusColumn = nullptr;
 		d->updateErrorBars();
 	}
 }
 
 void XYCurve::xErrorMinusColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->xErrorMinusColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->xErrorMinusColumn = nullptr;
 		d->updateErrorBars();
 	}
 }
 
 void XYCurve::yErrorPlusColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->yErrorPlusColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->yErrorPlusColumn = nullptr;
 		d->updateErrorBars();
 	}
 }
 
 void XYCurve::yErrorMinusColumnAboutToBeRemoved(const AbstractAspect* aspect) {
 	Q_D(XYCurve);
 	if (columnRemoved(d->yErrorMinusColumn, aspect)) {
 		disconnect(aspect, nullptr, this, nullptr);
 		d->yErrorMinusColumn = nullptr;
 		d->updateErrorBars();
 	}
 }
 
 void XYCurve::xColumnNameChanged() {
 	Q_D(XYCurve);
 	setXColumnPath(d->xColumn->path());
 }
 
 void XYCurve::yColumnNameChanged() {
 	Q_D(XYCurve);
 	setYColumnPath(d->yColumn->path());
 }
 
 void XYCurve::xErrorPlusColumnNameChanged() {
 	Q_D(XYCurve);
 	setXErrorPlusColumnPath(d->xErrorPlusColumn->path());
 }
 
 void XYCurve::xErrorMinusColumnNameChanged() {
 	Q_D(XYCurve);
 	setXErrorMinusColumnPath(d->xErrorMinusColumn->path());
 }
 
 void XYCurve::yErrorPlusColumnNameChanged() {
 	Q_D(XYCurve);
 	setYErrorPlusColumnPath(d->yErrorPlusColumn->path());
 }
 
 void XYCurve::yErrorMinusColumnNameChanged() {
 	Q_D(XYCurve);
 	setYErrorMinusColumnPath(d->yErrorMinusColumn->path());
 }
 
 void XYCurve::valuesColumnNameChanged() {
 	Q_D(XYCurve);
 	setValuesColumnPath(d->valuesColumn->path());
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void XYCurve::visibilityChanged() {
 	Q_D(const XYCurve);
 	this->setVisible(!d->isVisible());
 }
 
 void XYCurve::navigateTo() {
 	project()->navigateTo(navigateToAction->data().toString());
 }
 
 //##############################################################################
 //######################### Private implementation #############################
 //##############################################################################
 XYCurvePrivate::XYCurvePrivate(XYCurve *owner) : q(owner) {
 	setFlag(QGraphicsItem::ItemIsSelectable, true);
 	setAcceptHoverEvents(false);
 }
 
 QString XYCurvePrivate::name() const {
 	return q->name();
 }
 
 QRectF XYCurvePrivate::boundingRect() const {
 	return boundingRectangle;
 }
 
 /*!
   Returns the shape of the XYCurve as a QPainterPath in local coordinates
 */
 QPainterPath XYCurvePrivate::shape() const {
 	return curveShape;
 }
 
 void XYCurvePrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	if (q->activateCurve(event->pos())) {
 		q->createContextMenu()->exec(event->screenPos());
 		return;
 	}
 	QGraphicsItem::contextMenuEvent(event);
 }
 
 bool XYCurvePrivate::swapVisible(bool on) {
 	bool oldValue = isVisible();
 	setVisible(on);
 	emit q->visibilityChanged(on);
 	retransform();
 	return oldValue;
 }
 
 /*!
   called when the size of the plot or its data ranges (manual changes, zooming, etc.) were changed.
   recalculates the position of the scene points to be drawn.
   triggers the update of lines, drop lines, symbols etc.
 */
 void XYCurvePrivate::retransform() {
 
 	if (!isVisible())
 		return;
 
 	DEBUG("\nXYCurvePrivate::retransform() name = " << STDSTRING(name()) << ", m_suppressRetransform = " << m_suppressRetransform);
 	DEBUG("	plot = " << plot);
 	if (m_suppressRetransform || !plot)
 		return;
 
 	{
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::retransform()");
 #endif
 
 	symbolPointsScene.clear();
 
 	if ( (nullptr == xColumn) || (nullptr == yColumn) ) {
 		DEBUG("	xColumn or yColumn == NULL");
 		linePath = QPainterPath();
 		dropLinePath = QPainterPath();
 		symbolsPath = QPainterPath();
 		valuesPath = QPainterPath();
 		errorBarsPath = QPainterPath();
 		curveShape = QPainterPath();
 		lines.clear();
 		valuesPoints.clear();
 		valuesStrings.clear();
 		fillPolygons.clear();
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	if (!plot->isPanningActive())
 		WAIT_CURSOR;
 
 	//calculate the scene coordinates
 	// This condition cannot be used, because symbolPointsLogical is also used in updateErrorBars(), updateDropLines() and in updateFilling()
 	// TODO: check updateErrorBars() and updateDropLines() and if they aren't available don't calculate this part
 	//if (symbolsStyle != Symbol::NoSymbols || valuesType != XYCurve::NoValues ) {
 	{
 	#ifdef PERFTRACE_CURVES
 			PERFTRACE(name().toLatin1() + ", XYCurvePrivate::retransform(), map logical points to scene coordinates");
 	#endif
 
 	if (!symbolPointsLogical.isEmpty()) {
 		float widthDatarectInch = Worksheet::convertFromSceneUnits(plot->dataRect().width(), Worksheet::Inch);
 		float heightDatarectInch = Worksheet::convertFromSceneUnits(plot->dataRect().height(), Worksheet::Inch);
 		int countPixelX = ceil(widthDatarectInch*QApplication::desktop()->physicalDpiX());
 		int countPixelY = ceil(heightDatarectInch*QApplication::desktop()->physicalDpiY());
 
 		if (countPixelX <=0 || countPixelY <=0) {
 			RESET_CURSOR;
 			return;
 		}
 
 		double minLogicalDiffX = 1/(plot->dataRect().width()/countPixelX);
 		double minLogicalDiffY = 1/(plot->dataRect().height()/countPixelY);
 		QVector<QVector<bool>> scenePointsUsed;
 		// size of the datarect in pixels
 		scenePointsUsed.resize(countPixelX+1);
 		for (int i=0; i< countPixelX+1; i++)
 			scenePointsUsed[i].resize(countPixelY+1);
 
 		int columnProperties = xColumn->properties();
 		int startIndex;
 		int endIndex;
 		if (columnProperties == AbstractColumn::Properties::MonotonicDecreasing ||
 			columnProperties == AbstractColumn::Properties::MonotonicIncreasing) {
 			double xMin = cSystem->mapSceneToLogical(plot->dataRect().topLeft()).x();
 			double xMax = cSystem->mapSceneToLogical(plot->dataRect().bottomRight()).x();
 			startIndex = Column::indexForValue(xMin, symbolPointsLogical, static_cast<AbstractColumn::Properties>(columnProperties));
 			endIndex = Column::indexForValue(xMax, symbolPointsLogical, static_cast<AbstractColumn::Properties>(columnProperties));
 
 			if (startIndex > endIndex && startIndex >= 0 && endIndex >= 0)
 				std::swap(startIndex, endIndex);
 
 			if (startIndex < 0)
 				startIndex = 0;
 			if (endIndex < 0)
 				endIndex = symbolPointsLogical.size()-1;
 
 		} else {
 			startIndex = 0;
 			endIndex = symbolPointsLogical.size()-1;
 		}
 
 		visiblePoints = std::vector<bool>(symbolPointsLogical.count(), false);
 		cSystem->mapLogicalToScene(startIndex, endIndex, symbolPointsLogical,
 								   symbolPointsScene, visiblePoints, scenePointsUsed,
 								   minLogicalDiffX, minLogicalDiffY);
 	}
 	}
 	//} // (symbolsStyle != Symbol::NoSymbols || valuesType != XYCurve::NoValues )
 
 	m_suppressRecalc = true;
 	updateLines();
 	updateDropLines();
 	updateSymbols();
 	updateValues();
 	m_suppressRecalc = false;
 	updateErrorBars();
 
 	RESET_CURSOR;
 	}
 }
 
 /*!
  * called if the x- or y-data was changed.
  * copies the valid data points from the x- and y-columns into the internal container
  */
 void XYCurvePrivate::recalcLogicalPoints() {
 	DEBUG("XYCurvePrivate::recalcLogicalPoints()");
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::recalcLogicalPoints()");
 
 	symbolPointsLogical.clear();
 	connectedPointsLogical.clear();
 	validPointsIndicesLogical.clear();
 	visiblePoints.clear();
 
 	if (!xColumn || !yColumn)
 		return;
 
 	AbstractColumn::ColumnMode xColMode = xColumn->columnMode();
 	AbstractColumn::ColumnMode yColMode = yColumn->columnMode();
 	QPointF tempPoint;
 
 	//take over only valid and non masked points.
 	for (int row = 0; row < xColumn->rowCount(); row++) {
 		if ( xColumn->isValid(row) && yColumn->isValid(row)
 				&& (!xColumn->isMasked(row)) && (!yColumn->isMasked(row)) ) {
 			switch (xColMode) {
 			case AbstractColumn::Numeric:
 			case AbstractColumn::Integer:
 			case AbstractColumn::BigInt:
 				tempPoint.setX(xColumn->valueAt(row));
 				break;
 			case AbstractColumn::Text:
 				break;
 			case AbstractColumn::DateTime:
 				tempPoint.setX(xColumn->dateTimeAt(row).toMSecsSinceEpoch());
 				break;
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 
 			switch (yColMode) {
 			case AbstractColumn::Numeric:
 			case AbstractColumn::Integer:
 			case AbstractColumn::BigInt:
 				tempPoint.setY(yColumn->valueAt(row));
 				break;
 			case AbstractColumn::Text:
 				break;
 			case AbstractColumn::DateTime:
 				tempPoint.setY(yColumn->dateTimeAt(row).toMSecsSinceEpoch());
 				break;
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				break;
 			}
 			symbolPointsLogical.append(tempPoint);
 			connectedPointsLogical.push_back(true);
 			validPointsIndicesLogical.push_back(row);
 		} else {
 			if (!connectedPointsLogical.empty())
 				connectedPointsLogical[connectedPointsLogical.size()-1] = false;
 		}
 	}
 
 	visiblePoints = std::vector<bool>(symbolPointsLogical.count(), false);
 }
 
 /*!
  * Adds a line, which connects two points, but only if the don't lie on the same xAxis pixel.
  * If they lie on the same x pixel, draw a vertical line between the minimum and maximum y value. So all points are included
  * This function is only valid for linear x Axis scale!
  * @param p0 first point
  * @param p1 second point
  * @param minY
  * @param maxY
  * @param overlap if at the previous call was an overlap between the previous two points
  * @param minLogicalDiffX logical difference between two pixels
  * @param pixelDiff x pixel distance between two points
  */
 void XYCurvePrivate::addLine(QPointF p0, QPointF p1, double& minY, double& maxY, bool& overlap, double minLogicalDiffX, int& pixelDiff) {
 	pixelDiff = (int)(p1.x() * minLogicalDiffX) - (int)(p0.x() * minLogicalDiffX);
 
 	addLine(p0, p1, minY, maxY, overlap, pixelDiff);
 }
 
 /*!
  * Adds a line, which connects two points, but only if they don't lie on the same xAxis pixel.
  * If they lie on the same x pixel, draw a vertical line between the minimum and maximum y value. So all points are included
  * This function can be used for all axis scalings (linear, log, sqrt, ...). For the linear case use the function above, because it's optimized for the linear case
  * @param p0 first point
  * @param p1 second point
  * @param minY
  * @param maxY
  * @param overlap if at the previous call was an overlap between the previous two points
  * @param pixelDiff x pixel distance between two points
  * @param pixelCount pixel count
  */
 void XYCurvePrivate::addLine(QPointF p0, QPointF p1, double& minY, double& maxY, bool& overlap, int& pixelDiff, int pixelCount) {
 
 	if (plot->xScale() == CartesianPlot::Scale::ScaleLinear) { // implemented for completeness only
 		double minLogicalDiffX = 1./((plot->xMax() - plot->xMin())/pixelCount);
 		addLine(p0, p1, minY, maxY, overlap, minLogicalDiffX, pixelDiff);
 	} else {
 		// for nonlinear scaling the pixel distance must be calculated for every point pair
 		QPointF p0Scene = cSystem->mapLogicalToScene(p0, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 		QPointF p1Scene = cSystem->mapLogicalToScene(p1, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 
 		// if the point is not valid, don't create a line
 		//if (std::isnan(p0Scene.x()) || std::isnan(p0Scene.y()))
 		if ((p0Scene.x() == 0 && p0Scene.y() == 0) || (p1Scene.x() == 0 && p1Scene.y() == 0)) { // not possible to create line
 			DEBUG("Not possible to create a line between : " << p0Scene.x() << ' ' << p0Scene.y() << ", "<< p1Scene.x() << ' ' << p1Scene.y())
 			return;
 		}
 
 		// using only the difference between the points is not sufficient, because p0 is updated always
 		// independent if new line added or not
 		int p0Pixel = (int)((p0Scene.x() - plot->dataRect().x()) / plot->dataRect().width() * pixelCount);
 		int p1Pixel = (int)((p1Scene.x() - plot->dataRect().x()) / plot->dataRect().width() * pixelCount);
 		pixelDiff = p1Pixel - p0Pixel;
 		addLine(p0, p1, minY, maxY, overlap, pixelDiff);
 	}
 }
 
 /*!
  * \brief XYCurvePrivate::addLine
  * This function is called from the other two addLine() functions to avoid duplication
  * @param p0 first point
  * @param p1 second point
  * @param minY
  * @param maxY
  * @param overlap if at the previous call was an overlap between the previous two points
  * @param pixelDiff x pixel distance between two points
  */
 void XYCurvePrivate::addLine(QPointF p0, QPointF p1, double& minY, double& maxY, bool& overlap, int& pixelDiff) {
 	//QDEBUG("XYCurvePrivate::addLine():" << p0 << ' ' << p1 << ' ' << minY << ' ' << maxY << ' ' << overlap << ' ' << pixelDiff)
 	if (pixelDiff == 0) {
 		if (overlap) { // second and so the x axis pixels are the same
 		  if (p1.y() > maxY)
 			maxY = p1.y();
 
 		  if (p1.y() < minY)
 			minY = p1.y();
 
 		} else { // first time pixel are same
 			if (p0.y() < p1.y()) {
 				minY = p0.y();
 				maxY = p1.y();
 			} else {
 				maxY = p0.y();
 				minY = p1.y();
 			}
 			overlap = true;
 		}
 	} else {
 		if (overlap) { // when previously overlap was true, draw the previous line
 			overlap = false;
 
 			// last point from previous pixel must be evaluated
 			if (p0.y() > maxY)
 			  maxY = p0.y();
 
 			if (p0.y() < minY)
 			  minY = p0.y();
 
 
 			if (true) { //p1.x() >= plot->xMin() && p1.x() <= plot->xMax()) { // x inside scene
 				if (minY == maxY) {
 					lines.append(QLineF(p0, p1)); // line from previous point to actual point
 				} else if (p0.y() == minY) { // draw vertical line
 					lines.append(QLineF(p0.x(), maxY, p0.x(), minY));
 					if (p1.y() >= minY && p1.y() <= maxY && pixelDiff == 1)
 						return;
 
 					lines.append(QLineF(p0, p1));
 				} else if (p0.y() == maxY) { // draw vertical line
 					lines.append(QLineF(p0.x(), maxY, p0.x(), minY));
 					if (p1.y() >= minY && p1.y() <= maxY && pixelDiff == 1)
 						return;
 
 					// draw line, only if there is a pixelDiff = 1 otherwise no line needed, because when drawing a new vertical line, this line is already included
 					lines.append(QLineF(p0, p1));
 				} else { // last point nor min nor max
 					lines.append(QLineF(p0.x(), maxY, p0.x(), minY));
 					if (p1.y() >= minY && p1.y() <= maxY && pixelDiff == 1)
 						return;
 
 					lines.append(QLineF(p0, p1));
 				}
 			} else // x in scene
 				DEBUG("addLine: not in scene");
 		} else // no overlap
 			lines.append(QLineF(p0, p1));
 	}
 }
 
 /*!
   recalculates the painter path for the lines connecting the data points.
   Called each time when the type of this connection is changed.
   At the moment also the points which are outside of the scene are added. This algorithm can be improved by letting away all
   lines where both points are outside of the scene
 */
 void XYCurvePrivate::updateLines() {
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateLines()");
 #endif
 	linePath = QPainterPath();
 	lines.clear();
 	if (lineType == XYCurve::NoLine) {
 		DEBUG("	nothing to do, since line type is XYCurve::NoLine");
 		updateFilling();
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	unsigned int count = (unsigned int)symbolPointsLogical.count();
 	if (count <= 1) {
 		DEBUG("	nothing to do, since no data points available");
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	float widthDatarectInch = Worksheet::convertFromSceneUnits(plot->dataRect().width(), Worksheet::Inch);
 	//float heightDatarectInch = Worksheet::convertFromSceneUnits(plot->dataRect().height(), Worksheet::Inch);	// unsed
 	int countPixelX = ceil(widthDatarectInch*QApplication::desktop()->physicalDpiX());
 	//int countPixelY = ceil(heightDatarectInch*QApplication::desktop()->physicalDpiY());	// unused
 
 	// only valid for linear scale
 	//double minLogicalDiffX = 1/((plot->xMax()-plot->xMin())/countPixelX);	// unused
 	//double minLogicalDiffY = 1/((plot->yMax()-plot->yMin())/countPixelY); // unused
 
 	//calculate the lines connecting the data points
 	{
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateLines(), calculate the lines connecting the data points");
 #endif
 	QPointF tempPoint1, tempPoint2; // used as temporaryPoints to interpolate datapoints if the corresponding setting is set
 	int startIndex, endIndex;
 
 	// find index for xMin and xMax to not loop throug all values
 	AbstractColumn::Properties columnProperties = q->xColumn()->properties();
 	if (columnProperties == AbstractColumn::Properties::MonotonicDecreasing ||
 		columnProperties == AbstractColumn::Properties::MonotonicIncreasing) {
 		double xMin = cSystem->mapSceneToLogical(plot->dataRect().topLeft()).x();
 		double xMax = cSystem->mapSceneToLogical(plot->dataRect().bottomRight()).x();
 		startIndex= Column::indexForValue(xMin, symbolPointsLogical, columnProperties);
 		endIndex = Column::indexForValue(xMax, symbolPointsLogical, columnProperties);
 
 		if (startIndex > endIndex)
 			std::swap(startIndex, endIndex);
 
 		startIndex--; // use one value before
 		endIndex ++;
 		if (startIndex < 0)
 			startIndex = 0;
 		if(endIndex < 0 || endIndex >= static_cast<int>(count))
 			endIndex = static_cast<int>(count)-1;
 
 		count = static_cast<unsigned int>(endIndex - startIndex +1);
 	}else {
 		startIndex = 0;
 		endIndex = static_cast<int>(count)-1;
 	}
 
 	if (columnProperties == AbstractColumn::Properties::Constant) {
 		tempPoint1 = QPointF(plot->xMin(), plot->yMin());
 		tempPoint2 = QPointF(plot->xMin(), plot->yMax());
 		lines.append(QLineF(tempPoint1, tempPoint2));
 	} else {
 		bool overlap = false;
 		double maxY, minY; // are initialized in add line()
 		int pixelDiff;
 		QPointF p0;
 		QPointF p1;
 
 		switch (lineType) {
 		case XYCurve::NoLine:
 			break;
 		case XYCurve::Line: {
 			for (int i = startIndex; i < endIndex; i++) {
 				if (!lineSkipGaps && !connectedPointsLogical[i])
 					continue;
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (lineIncreasingXOnly && (p1.x() < p0.x())) // when option set skip points
 					continue;
 				addLine(p0, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(QPointF(p1.x(), minY), QPointF(p1.x(), maxY)));
 
 			break;
 		}
 		case XYCurve::StartHorizontal: {
 			for (int i = startIndex; i < endIndex; i++) {
 				if (!lineSkipGaps && !connectedPointsLogical[i])
 					continue;
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (lineIncreasingXOnly && (p1.x() < p0.x()))
 					continue;
 
 				tempPoint1 = QPointF(p1.x(), p0.y());
 				addLine(p0, tempPoint1, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint1, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(QPointF(p1.x(), minY), QPointF(p1.x(), maxY)));
 
 			break;
 		}
 		case XYCurve::StartVertical: {
 			for (int i = startIndex; i < endIndex; i++) {
 				if (!lineSkipGaps && !connectedPointsLogical[i])
 					continue;
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (lineIncreasingXOnly && (p1.x() < p0.x()))
 					continue;
 				tempPoint1 = QPointF(p0.x(), p1.y());
 				addLine(p0, tempPoint1, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint1, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(QPointF(p1.x(), minY), QPointF(p1.x(), maxY)));
 
 			break;
 		}
 		case XYCurve::MidpointHorizontal: {
 			for (int i = startIndex; i < endIndex; i++) {
 				if (!lineSkipGaps && !connectedPointsLogical[i])
 					continue;
 
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (lineIncreasingXOnly && (p1.x() < p0.x()))
 					continue;
 				tempPoint1 = QPointF(p0.x() + (p1.x()-p0.x())/2, p0.y());
 				tempPoint2 = QPointF(p0.x() + (p1.x()-p0.x())/2, p1.y());
 				addLine(p0, tempPoint1, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint1, tempPoint2, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint2, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(QPointF(p1.x(), minY), QPointF(p1.x(), maxY)));
 
 			break;
 		}
 		case XYCurve::MidpointVertical: {
 			for (int i = startIndex; i < endIndex; i++) {
 				if (!lineSkipGaps && !connectedPointsLogical[i])
 					continue;
 
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (lineIncreasingXOnly && (p1.x() < p0.x()))
 					continue;
 				tempPoint1 = QPointF(p0.x(), p0.y() + (p1.y()-p0.y())/2);
 				tempPoint2 = QPointF(p1.x(), p0.y() + (p1.y()-p0.y())/2);
 				addLine(p0, tempPoint1, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint1, tempPoint2, minY, maxY, overlap, pixelDiff, countPixelX);
 				addLine(tempPoint2, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(QPointF(p1.x(), minY), QPointF(p1.x(), maxY)));
 
 			break;
 		}
 		case XYCurve::Segments2: {
 			int skip = 0;
 			for (int i = startIndex; i < endIndex; i++) {
 				p0 = symbolPointsLogical[i];
 				p1 = symbolPointsLogical[i+1];
 				if (skip != 1) {
 					if ( (!lineSkipGaps && !connectedPointsLogical[i])
 						|| (lineIncreasingXOnly && (p1.x() < p0.x())) ) {
 						skip = 0;
 						continue;
 					}
 					addLine(p0, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 					skip++;
 				} else {
 					skip = 0;
 					if (overlap) {
 						overlap = false;
 						lines.append(QLineF(QPointF(p0.x(), minY), QPointF(p0.x(), maxY)));
 					}
 				}
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(symbolPointsLogical[endIndex-1], symbolPointsLogical[endIndex]));
 
 			break;
 		}
 		case XYCurve::Segments3: {
 			int skip = 0;
 			for (int i = startIndex; i < endIndex; i++) {
 				if (skip != 2) {
 					p0 = symbolPointsLogical[i];
 					p1 = symbolPointsLogical[i+1];
 					if ( (!lineSkipGaps && !connectedPointsLogical[i])
 						|| (lineIncreasingXOnly && (p1.x() < p0.x())) ) {
 						skip = 0;
 						continue;
 					}
 					addLine(p0, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 					skip++;
 				} else {
 					skip = 0;
 					if (overlap) {
 						overlap = false;
 						lines.append(QLineF(QPointF(p0.x(), minY), QPointF(p0.x(), maxY)));
 					}
 				}
 			}
 			// add last line
 			if (overlap)
 				lines.append(QLineF(symbolPointsLogical[endIndex-1], symbolPointsLogical[endIndex]));
 
 			break;
 		}
 		case XYCurve::SplineCubicNatural:
 		case XYCurve::SplineCubicPeriodic:
 		case XYCurve::SplineAkimaNatural:
 		case XYCurve::SplineAkimaPeriodic: {
 			gsl_interp_accel *acc = gsl_interp_accel_alloc();
 			gsl_spline *spline = nullptr;
 
 			double* x = new double[count];
 			double* y = new double[count];
 			for (unsigned int i = 0; i < count; i++) { // TODO: interpolating only between the visible points?
 				x[i] = symbolPointsLogical[i+startIndex].x();
 				y[i] = symbolPointsLogical[i+startIndex].y();
 			}
 
 			gsl_set_error_handler_off();
 			if (lineType == XYCurve::SplineCubicNatural)
 				spline = gsl_spline_alloc(gsl_interp_cspline, count);
 			else if (lineType == XYCurve::SplineCubicPeriodic)
 				spline = gsl_spline_alloc(gsl_interp_cspline_periodic, count);
 			else if (lineType == XYCurve::SplineAkimaNatural)
 				spline = gsl_spline_alloc(gsl_interp_akima, count);
 			else if (lineType == XYCurve::SplineAkimaPeriodic)
 				spline = gsl_spline_alloc(gsl_interp_akima_periodic, count);
 
 			if (!spline) {
 				QString msg;
 				if ( (lineType == XYCurve::SplineAkimaNatural || lineType == XYCurve::SplineAkimaPeriodic) && count < 5)
 					msg = i18n("Error: Akima spline interpolation requires a minimum of 5 points.");
 				else
 					msg = i18n("Error: Could not initialize the spline function.");
 				emit q->info(msg);
 
 				recalcShapeAndBoundingRect();
 				delete[] x;
 				delete[] y;
 				gsl_interp_accel_free (acc);
 				return;
 			}
 
 			int status = gsl_spline_init (spline, x, y, count);
 			if (status) {
 				//TODO: check in gsl/interp.c when GSL_EINVAL is thrown
 				QString gslError;
 				if (status == GSL_EINVAL)
 					gslError = i18n("x values must be monotonically increasing.");
 				else
 					gslError = gslErrorToString(status);
 				emit q->info( i18n("Error: %1", gslError) );
 
 				recalcShapeAndBoundingRect();
 				delete[] x;
 				delete[] y;
 				gsl_spline_free (spline);
 				gsl_interp_accel_free (acc);
 				return;
 			}
 
 			//create interpolating points
 			std::vector<double> xinterp, yinterp;
 			for (unsigned int i = 0; i < count - 1; i++) {
 				const double x1 = x[i];
 				const double x2 = x[i+1];
 				const double step = fabs(x2 - x1)/(lineInterpolationPointsCount + 1);
 
 				for (int i = 0; i < (lineInterpolationPointsCount + 1); i++) {
 					double xi = x1+i*step;
 					double yi = gsl_spline_eval(spline, xi, acc);
 					xinterp.push_back(xi);
 					yinterp.push_back(yi);
 				}
 			}
 
 			if (!xinterp.empty()) {
 
 				for (unsigned int i = 0; i < xinterp.size() - 1; i++) {
 					p0 = QPointF(xinterp[i], yinterp[i]);
 					p1 = QPointF(xinterp[i+1], yinterp[i+1]);
 					addLine(p0, p1, minY, maxY, overlap, pixelDiff, countPixelX);
 				}
 
 				addLine(QPointF(xinterp[xinterp.size()-1], yinterp[yinterp.size()-1]), QPointF(x[count-1], y[count-1]), minY, maxY, overlap, pixelDiff, countPixelX);
 
 				// add last line
 				if (overlap)
 					lines.append(QLineF(QPointF(xinterp[xinterp.size()-1], yinterp[yinterp.size()-1]), QPointF(x[count-1], y[count-1])));
 			}
 
 			delete[] x;
 			delete[] y;
 			gsl_spline_free (spline);
 			gsl_interp_accel_free (acc);
 			break;
 			}
 		}
 	}
 	}
 
 	//map the lines to scene coordinates
 	{
 #ifdef PERFTRACE_CURVES
 		PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateLines(), map lines to scene coordinates");
 #endif
 		lines = cSystem->mapLogicalToScene(lines);
 	}
 
 	{
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateLines(), calculate new line path");
 #endif
 	//new line path
 	for (const auto& line : lines) {
 		linePath.moveTo(line.p1());
 		linePath.lineTo(line.p2());
 	}
 	}
 
 	updateFilling();
 	recalcShapeAndBoundingRect();
 }
 
 /*!
   recalculates the painter path for the drop lines.
   Called each time when the type of the drop lines is changed.
 */
 void XYCurvePrivate::updateDropLines() {
 	dropLinePath = QPainterPath();
 	if (dropLineType == XYCurve::NoDropLine) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//calculate drop lines
 	QVector<QLineF> lines;
 	float xMin = 0;
 	float yMin = 0;
 
 	xMin = plot->xMin();
 	yMin = plot->yMin();
 	switch (dropLineType) {
 	case XYCurve::NoDropLine:
 		break;
 	case XYCurve::DropLineX:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append(QLineF(point, QPointF(point.x(), yMin)));
 		}
 		break;
 	case XYCurve::DropLineY:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append(QLineF(point, QPointF(xMin, point.y())));
 		}
 		break;
 	case XYCurve::DropLineXY:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append(QLineF(point, QPointF(point.x(), yMin)));
 			lines.append(QLineF(point, QPointF(xMin, point.y())));
 		}
 		break;
 	case XYCurve::DropLineXZeroBaseline:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append(QLineF(point, QPointF(point.x(), 0)));
 		}
 		break;
 	case XYCurve::DropLineXMinBaseline:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append( QLineF(point, QPointF(point.x(), yColumn->minimum())) );
 		}
 		break;
 	case XYCurve::DropLineXMaxBaseline:
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			const QPointF& point = symbolPointsLogical.at(i);
 			lines.append( QLineF(point, QPointF(point.x(), yColumn->maximum())) );
 		}
 		break;
 	}
 
 	//map the drop lines to scene coordinates
 	lines = cSystem->mapLogicalToScene(lines);
 
 	//new painter path for the drop lines
 	for (const auto& line : lines) {
 		dropLinePath.moveTo(line.p1());
 		dropLinePath.lineTo(line.p2());
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void XYCurvePrivate::updateSymbols() {
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateSymbols()");
 #endif
 	symbolsPath = QPainterPath();
 	if (symbolsStyle != Symbol::NoSymbols) {
 		QPainterPath path = Symbol::pathFromStyle(symbolsStyle);
 
 		QTransform trafo;
 		trafo.scale(symbolsSize, symbolsSize);
 		path = trafo.map(path);
 		trafo.reset();
 
 		if (symbolsRotationAngle != 0) {
 			trafo.rotate(symbolsRotationAngle);
 			path = trafo.map(path);
 		}
 
 		for (const auto& point : symbolPointsScene) {
 			trafo.reset();
 			trafo.translate(point.x(), point.y());
 			symbolsPath.addPath(trafo.map(path));
 		}
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 /*!
   recreates the value strings to be shown and recalculates their draw position.
 */
 void XYCurvePrivate::updateValues() {
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::updateValues()");
 #endif
 	valuesPath = QPainterPath();
 	valuesPoints.clear();
 	valuesStrings.clear();
 
 	if (valuesType == XYCurve::NoValues) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	//determine the value string for all points that are currently visible in the plot
 	switch (valuesType) {
 	case XYCurve::NoValues:
 	case XYCurve::ValuesX: {
 		CartesianPlot::RangeFormat rangeFormat = plot->xRangeFormat();
 		int precision = valuesPrecision;
 		if (xColumn->columnMode() == AbstractColumn::Integer || xColumn->columnMode() == AbstractColumn::BigInt)
 			precision = 0;
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			QString value;
 			if (rangeFormat == CartesianPlot::Numeric)
 				value = QString::number(symbolPointsLogical[i].x(), valuesNumericFormat, precision);
 			else
 				value = QDateTime::fromMSecsSinceEpoch(symbolPointsLogical[i].x()).toString(valuesDateTimeFormat);
 			valuesStrings << valuesPrefix + value + valuesSuffix;
 		}
 		break;
 	}
 	case XYCurve::ValuesY: {
 		CartesianPlot::RangeFormat rangeFormat = plot->yRangeFormat();
 		int precision = valuesPrecision;
 		if (yColumn->columnMode() == AbstractColumn::Integer || yColumn->columnMode() == AbstractColumn::BigInt)
 			precision = 0;
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			QString value;
 			if (rangeFormat == CartesianPlot::Numeric)
 				value = QString::number(symbolPointsLogical[i].y(), valuesNumericFormat, precision);
 			else
 				value = QDateTime::fromMSecsSinceEpoch(symbolPointsLogical[i].y()).toString(valuesDateTimeFormat);
 			valuesStrings << valuesPrefix + value + valuesSuffix;
 		}
 		break;
 	}
 	case XYCurve::ValuesXY:
 	case XYCurve::ValuesXYBracketed: {
 		CartesianPlot::RangeFormat xRangeFormat = plot->xRangeFormat();
 		CartesianPlot::RangeFormat yRangeFormat = plot->yRangeFormat();
 
 		int xPrecision = valuesPrecision;
 		if (xColumn->columnMode() == AbstractColumn::Integer || xColumn->columnMode() == AbstractColumn::BigInt)
 			xPrecision = 0;
 
 		int yPrecision = valuesPrecision;
 		if (yColumn->columnMode() == AbstractColumn::Integer || yColumn->columnMode() == AbstractColumn::BigInt)
 			yPrecision = 0;
 
 		for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 			if (!visiblePoints[i]) continue;
 			QString value;
 			if (valuesType == XYCurve::ValuesXYBracketed)
 				value = '(';
 			if (xRangeFormat == CartesianPlot::Numeric)
 				value += QString::number(symbolPointsLogical[i].x(), valuesNumericFormat, xPrecision);
 			else
 				value += QDateTime::fromMSecsSinceEpoch(symbolPointsLogical[i].x()).toString(valuesDateTimeFormat);
 
 			if (yRangeFormat == CartesianPlot::Numeric)
 				value += ',' + QString::number(symbolPointsLogical[i].y(), valuesNumericFormat, yPrecision);
 			else
 				value += ',' + QDateTime::fromMSecsSinceEpoch(symbolPointsLogical[i].y()).toString(valuesDateTimeFormat);
 
 			if (valuesType == XYCurve::ValuesXYBracketed)
 				value += ')';
 
 			valuesStrings << valuesPrefix + value + valuesSuffix;
 		}
 		break;
 	}
 	case XYCurve::ValuesCustomColumn: {
 		if (!valuesColumn) {
 			recalcShapeAndBoundingRect();
 			return;
 		}
 
 		int endRow;
 		if (symbolPointsLogical.size()>valuesColumn->rowCount())
 			endRow =  valuesColumn->rowCount();
 		else
 			endRow = symbolPointsLogical.size();
 
 		AbstractColumn::ColumnMode xColMode = valuesColumn->columnMode();
 		for (int i = 0; i < endRow; ++i) {
 			if (!visiblePoints[i]) continue;
 
 			if ( !valuesColumn->isValid(i) || valuesColumn->isMasked(i) )
 				continue;
 
 			switch (xColMode) {
 			case AbstractColumn::Numeric:
 			case AbstractColumn::Integer:
 			case AbstractColumn::BigInt:
 				valuesStrings << valuesPrefix + QString::number(valuesColumn->valueAt(i)) + valuesSuffix;
 				break;
 			case AbstractColumn::Text:
 				valuesStrings << valuesPrefix + valuesColumn->textAt(i) + valuesSuffix;
 				break;
 			case AbstractColumn::DateTime:
 			case AbstractColumn::Month:
 			case AbstractColumn::Day:
 				valuesStrings << valuesPrefix + valuesColumn->dateTimeAt(i).toString(valuesDateTimeFormat) + valuesSuffix;
 				break;
 			}
 		}
 	}
 	}
 
 	//Calculate the coordinates where to paint the value strings.
 	//The coordinates depend on the actual size of the string.
 	QPointF tempPoint;
 	QFontMetrics fm(valuesFont);
 	qreal w;
 	qreal h = fm.ascent();
 
 	for (int i = 0; i < valuesStrings.size(); i++) {
 		w = fm.boundingRect(valuesStrings.at(i)).width();
 		switch (valuesPosition) {
 		case XYCurve::ValuesAbove:
 			tempPoint.setX( symbolPointsScene.at(i).x() - w/2);
 			tempPoint.setY( symbolPointsScene.at(i).y() - valuesDistance );
 			break;
 		case XYCurve::ValuesUnder:
 			tempPoint.setX( symbolPointsScene.at(i).x() -w/2 );
 			tempPoint.setY( symbolPointsScene.at(i).y() + valuesDistance + h/2);
 			break;
 		case XYCurve::ValuesLeft:
 			tempPoint.setX( symbolPointsScene.at(i).x() - valuesDistance - w - 1 );
 			tempPoint.setY( symbolPointsScene.at(i).y());
 			break;
 		case XYCurve::ValuesRight:
 			tempPoint.setX( symbolPointsScene.at(i).x() + valuesDistance - 1 );
 			tempPoint.setY( symbolPointsScene.at(i).y() );
 			break;
 		}
 		valuesPoints.append(tempPoint);
 	}
 
 	QTransform trafo;
 	QPainterPath path;
 	for (int i = 0; i < valuesPoints.size(); i++) {
 		path = QPainterPath();
 		path.addText( QPoint(0,0), valuesFont, valuesStrings.at(i) );
 
 		trafo.reset();
 		trafo.translate( valuesPoints.at(i).x(), valuesPoints.at(i).y() );
 		if (valuesRotationAngle != 0)
 			trafo.rotate( -valuesRotationAngle );
 
 		valuesPath.addPath(trafo.map(path));
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 void XYCurvePrivate::updateFilling() {
 	if (m_suppressRetransform)
 		return;
 
 	fillPolygons.clear();
 
 	//don't try to calculate the filling polygons if
 	// - no filling was enabled
 	// - the nubmer of visible points on the scene is too high
 	// - no scene points available, everything outside of the plot region or no scene points calculated yet
 	if (fillingPosition == XYCurve::NoFilling || symbolPointsScene.size() > 1000 || symbolPointsScene.isEmpty()) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	QVector<QLineF> fillLines;
 
 	//if there're no interpolation lines available (XYCurve::NoLine selected), create line-interpolation,
 	//use already available lines otherwise.
 	if (!lines.isEmpty())
 		fillLines = lines;
 	else {
 		for (int i = 0; i < symbolPointsLogical.count() - 1; i++) {
 			if (!lineSkipGaps && !connectedPointsLogical[i]) continue;
 			fillLines.append(QLineF(symbolPointsLogical.at(i), symbolPointsLogical.at(i+1)));
 		}
 
 		//no lines available (no points), nothing to do
 		if (fillLines.isEmpty())
 			return;
 
 		fillLines = cSystem->mapLogicalToScene(fillLines);
 
 		//no lines available (no points) after mapping, nothing to do
 		if (fillLines.isEmpty())
 			return;
 	}
 
 	//create polygon(s):
 	//1. Depending on the current zoom-level, only a subset of the curve may be visible in the plot
 	//and more of the filling area should be shown than the area defined by the start and end points of the currently visible points.
 	//We check first whether the curve crosses the boundaries of the plot and determine new start and end points and put them to the boundaries.
 	//2. Furthermore, depending on the current filling type we determine the end point (x- or y-coordinate) where all polygons are closed at the end.
 	QPolygonF pol;
 	QPointF start = fillLines.at(0).p1(); //starting point of the current polygon, initialize with the first visible point
 	QPointF end = fillLines.at(fillLines.size()-1).p2(); //end point of the current polygon, initialize with the last visible point
 	const QPointF& first = symbolPointsLogical.at(0); //first point of the curve, may not be visible currently
 	const QPointF& last = symbolPointsLogical.at(symbolPointsLogical.size()-1);//last point of the curve, may not be visible currently
 	QPointF edge;
 	float xEnd = 0, yEnd = 0;
 	if (fillingPosition == XYCurve::FillingAbove) {
 		edge = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin()));
 
 		//start point
 		if (AbstractCoordinateSystem::essentiallyEqual(start.y(), edge.y())) {
 			if (first.x() < plot->xMin())
 				start = edge;
 			else if (first.x() > plot->xMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMin()));
 		}
 
 		//end point
 		if (AbstractCoordinateSystem::essentiallyEqual(end.y(), edge.y())) {
 			if (last.x() < plot->xMin())
 				end = edge;
 			else if (last.x() > plot->xMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMin()));
 		}
 
 		//coordinate at which to close all polygons
 		yEnd = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax())).y();
 	} else if (fillingPosition == XYCurve::FillingBelow) {
 		edge = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax()));
 
 		//start point
 		if (AbstractCoordinateSystem::essentiallyEqual(start.y(), edge.y())) {
 			if (first.x() < plot->xMin())
 				start = edge;
 			else if (first.x() > plot->xMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMax()));
 		}
 
 		//end point
 		if (AbstractCoordinateSystem::essentiallyEqual(end.y(), edge.y())) {
 			if (last.x() < plot->xMin())
 				end = edge;
 			else if (last.x() > plot->xMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMax()));
 		}
 
 		//coordinate at which to close all polygons
 		yEnd = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin())).y();
 	} else if (fillingPosition == XYCurve::FillingZeroBaseline) {
 		edge = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax()));
 
 		//start point
 		if (AbstractCoordinateSystem::essentiallyEqual(start.y(), edge.y())) {
 			if (plot->yMax() > 0) {
 				if (first.x() < plot->xMin())
 					start = edge;
 				else if (first.x() > plot->xMax())
 					start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 				else
 					start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMax()));
 			} else {
 				if (first.x() < plot->xMin())
 					start = edge;
 				else if (first.x() > plot->xMax())
 					start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 				else
 					start = cSystem->mapLogicalToScene(QPointF(first.x(), plot->yMin()));
 			}
 		}
 
 		//end point
 		if (AbstractCoordinateSystem::essentiallyEqual(end.y(), edge.y())) {
 			if (plot->yMax() > 0) {
 				if (last.x() < plot->xMin())
 					end = edge;
 				else if (last.x() > plot->xMax())
 					end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 				else
 					end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMax()));
 			} else {
 				if (last.x() < plot->xMin())
 					end = edge;
 				else if (last.x() > plot->xMax())
 					end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 				else
 					end = cSystem->mapLogicalToScene(QPointF(last.x(), plot->yMin()));
 			}
 		}
 
 		yEnd = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin()>0 ? plot->yMin() : 0)).y();
 	} else if (fillingPosition == XYCurve::FillingLeft) {
 		edge = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin()));
 
 		//start point
 		if (AbstractCoordinateSystem::essentiallyEqual(start.x(), edge.x())) {
 			if (first.y() < plot->yMin())
 				start = edge;
 			else if (first.y() > plot->yMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMax(), first.y()));
 		}
 
 		//end point
 		if (AbstractCoordinateSystem::essentiallyEqual(end.x(), edge.x())) {
 			if (last.y() < plot->yMin())
 				end = edge;
 			else if (last.y() > plot->yMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMax()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMax(), last.y()));
 		}
 
 		//coordinate at which to close all polygons
 		xEnd = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin())).x();
 	} else { //FillingRight
 		edge = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMin()));
 
 		//start point
 		if (AbstractCoordinateSystem::essentiallyEqual(start.x(), edge.x())) {
 			if (first.y() < plot->yMin())
 				start = edge;
 			else if (first.y() > plot->yMax())
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax()));
 			else
 				start = cSystem->mapLogicalToScene(QPointF(plot->xMin(), first.y()));
 		}
 
 		//end point
 		if (AbstractCoordinateSystem::essentiallyEqual(end.x(), edge.x())) {
 			if (last.y() < plot->yMin())
 				end = edge;
 			else if (last.y() > plot->yMax())
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMin(), plot->yMax()));
 			else
 				end = cSystem->mapLogicalToScene(QPointF(plot->xMin(), last.y()));
 		}
 
 		//coordinate at which to close all polygons
 		xEnd = cSystem->mapLogicalToScene(QPointF(plot->xMax(), plot->yMin())).x();
 	}
 
 	if (start != fillLines.at(0).p1())
 		pol << start;
 
 	QPointF p1, p2;
 	for (int i = 0; i < fillLines.size(); ++i) {
 		const QLineF& line = fillLines.at(i);
 		p1 = line.p1();
 		p2 = line.p2();
 		if (i != 0 && p1 != fillLines.at(i-1).p2()) {
 			//the first point of the current line is not equal to the last point of the previous line
 			//->check whether we have a break in between.
 			const bool gap = false; //TODO
 			if (!gap) {
 				//-> we have no break in the curve -> connect the points by a horizontal/vertical line
 				pol << fillLines.at(i-1).p2() << p1;
 			} else {
 				//-> we have a break in the curve -> close the polygon, add it to the polygon list and start a new polygon
 				if (fillingPosition == XYCurve::FillingAbove || fillingPosition == XYCurve::FillingBelow || fillingPosition == XYCurve::FillingZeroBaseline) {
 					pol << QPointF(fillLines.at(i-1).p2().x(), yEnd);
 					pol << QPointF(start.x(), yEnd);
 				} else {
 					pol << QPointF(xEnd, fillLines.at(i-1).p2().y());
 					pol << QPointF(xEnd, start.y());
 				}
 
 				fillPolygons << pol;
 				pol.clear();
 				start = p1;
 			}
 		}
 		pol << p1 << p2;
 	}
 
 	if (p2 != end)
 		pol << end;
 
 	//close the last polygon
 	if (fillingPosition == XYCurve::FillingAbove || fillingPosition == XYCurve::FillingBelow || fillingPosition == XYCurve::FillingZeroBaseline) {
 		pol << QPointF(end.x(), yEnd);
 		pol << QPointF(start.x(), yEnd);
 	} else {
 		pol << QPointF(xEnd, end.y());
 		pol << QPointF(xEnd, start.y());
 	}
 
 	fillPolygons << pol;
 	recalcShapeAndBoundingRect();
 }
 
  /*!
  * Find y value which corresponds to a @p x . @p valueFound indicates, if value was found.
  * When monotonic increasing or decreasing a different algorithm will be used, which needs less steps (mean) (log_2(rowCount)) to find the value.
  * @param x
  * @param valueFound
  * @return
  */
 double XYCurve::y(double x, bool &valueFound) const {
 	if (!yColumn() || !xColumn()) {
 		valueFound = false;
 		return NAN;
 	}
 
 	AbstractColumn::ColumnMode yColumnMode = yColumn()->columnMode();
 	int index = xColumn()->indexForValue(x);
 	if (index < 0) {
 		valueFound = false;
 		return NAN;
 	}
 
 	valueFound = true;
 	if (yColumnMode == AbstractColumn::ColumnMode::Numeric || yColumnMode == AbstractColumn::ColumnMode::Integer ||
 			yColumnMode == AbstractColumn::ColumnMode::BigInt) {
 		return yColumn()->valueAt(index);
 	} else {
 		valueFound = false;
 		return NAN;
 	}
 }
 
 /*!
 * Find y DateTime which corresponds to a @p x . @p valueFound indicates, if value was found.
 * When monotonic increasing or decreasing a different algorithm will be used, which needs less steps (mean) (log_2(rowCount)) to find the value.
 * @param x
 * @param valueFound
 * @return Return found value
 */
 QDateTime XYCurve::yDateTime(double x, bool &valueFound) const {
 	if (!yColumn() || !xColumn()) {
 		valueFound = false;
 		return QDateTime();
 	}
    AbstractColumn::ColumnMode yColumnMode = yColumn()->columnMode();
    int index = xColumn()->indexForValue(x);
    if (index < 0) {
 	   valueFound = false;
 	   return QDateTime();
    }
 
    valueFound = true;
    if (yColumnMode == AbstractColumn::ColumnMode::Day ||
 	   yColumnMode == AbstractColumn::ColumnMode::Month ||
 	   yColumnMode == AbstractColumn::ColumnMode::DateTime)
 	   return yColumn()->dateTimeAt(index);
 
    valueFound = false;
    return QDateTime();
 }
 
 bool XYCurve::minMaxY(int indexMin, int indexMax, double& yMin, double& yMax, bool includeErrorBars) const {
 	return minMax(yColumn(), xColumn(), yErrorType(), yErrorPlusColumn(), yErrorMinusColumn(), indexMin, indexMax, yMin, yMax, includeErrorBars);
 }
 
 bool XYCurve::minMaxX(int indexMin, int indexMax, double& xMin, double& xMax, bool includeErrorBars) const {
 	return minMax(xColumn(), yColumn(), xErrorType(), xErrorPlusColumn(), xErrorMinusColumn(), indexMin, indexMax, xMin, xMax, includeErrorBars);
 }
 
 /*!
  * Calculates the minimum \p min and maximum \p max of a curve with optionally respecting the error bars
  * This function does not check if the values are out of range
  * \p indexMax is not included
  * \p column
  * \p errorType
  * \p errorPlusColumn
  * \p errorMinusColumn
  * \p indexMin
  * \p indexMax
  * \p min
  * \p max
  * \ includeErrorBars If true respect the error bars in the min/max calculation
  */
 bool XYCurve::minMax(const AbstractColumn* column1, const AbstractColumn* column2, const ErrorType errorType, const AbstractColumn* errorPlusColumn, const AbstractColumn* errorMinusColumn, int indexMin, int indexMax, double& min, double& max, bool includeErrorBars) const {
 	// when property is greater than 1 there is a benefit in finding minimum and maximum
 	// for property == 0 it must be iterated over all values so it does not matter if this function or the below one is used
 	// if the property of the second column is greater 0 means, that all values are valid and not masked
 	if ((!includeErrorBars || errorType == XYCurve::NoError) && column1->properties() > 0 && column2 && column2->properties() > 0) {
 		min = column1->minimum(indexMin, indexMax);
 		max = column1->maximum(indexMin, indexMax);
 		return true;
 	}
 
 	if (column1->rowCount() == 0)
 		return false;
 
 	min = INFINITY;
 	max = -INFINITY;
 
 	for (int i = indexMin; i < indexMax; ++i) {
 		if (!column1->isValid(i) || column1->isMasked(i) || (column2 && (!column2->isValid(i) || column2->isMasked(i))))
 			continue;
 
 		if ( (errorPlusColumn && i >= errorPlusColumn->rowCount())
 			|| (errorMinusColumn && i >= errorMinusColumn->rowCount()) )
 			continue;
 
 		//determine the values for the errors
 		double errorPlus, errorMinus;
 		if (errorPlusColumn && errorPlusColumn->isValid(i) && !errorPlusColumn->isMasked(i))
 			if (errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::Numeric ||
 					errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::Integer ||
 					errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::BigInt)
 				errorPlus = errorPlusColumn->valueAt(i);
 			else if (errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::DateTime ||
 					 errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::Month ||
 					 errorPlusColumn->columnMode() == AbstractColumn::ColumnMode::Day)
 				errorPlus = errorPlusColumn->dateTimeAt(i).toMSecsSinceEpoch();
 			else
 				return false;
 		else
 			errorPlus = 0;
 
 		if (errorType == XYCurve::SymmetricError)
 			errorMinus = errorPlus;
 		else {
 			if (errorMinusColumn && errorMinusColumn->isValid(i) && !errorMinusColumn->isMasked(i))
 				if (errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::Numeric ||
 					errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::Integer ||
 					errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::BigInt)
 					errorMinus = errorMinusColumn->valueAt(i);
 				else if (errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::DateTime ||
 						 errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::Month ||
 						 errorMinusColumn->columnMode() == AbstractColumn::ColumnMode::Day)
 					errorMinus = errorMinusColumn->dateTimeAt(i).toMSecsSinceEpoch();
 				else
 					return false;
 			else
 				errorMinus = 0;
 		}
 
 		double value;
 		if (column1->columnMode() == AbstractColumn::ColumnMode::Numeric || column1->columnMode() == AbstractColumn::ColumnMode::Integer ||
 				column1->columnMode() == AbstractColumn::ColumnMode::BigInt)
 			value = column1->valueAt(i);
 		else if (column1->columnMode() == AbstractColumn::ColumnMode::DateTime ||
 				 column1->columnMode() == AbstractColumn::ColumnMode::Month ||
 				 column1->columnMode() == AbstractColumn::ColumnMode::Day) {
 			value = column1->dateTimeAt(i).toMSecsSinceEpoch();
 		} else
 			return false;
 
 		if (value - errorMinus < min)
 			min = value - errorMinus;
 
 		if (value + errorPlus > max)
 			max = value + errorPlus;
 	}
 	return true;
 }
 
 /*!
  * \brief XYCurve::activateCurve
  * Checks if the mousepos distance to the curve is less than @p pow(maxDist,2)
  * \p mouseScenePos
  * \p maxDist Maximum distance the point lies away from the curve
  * \return Returns true if the distance is smaller than pow(maxDist,2).
  */
 bool XYCurve::activateCurve(QPointF mouseScenePos, double maxDist) {
 	Q_D(XYCurve);
 	return d->activateCurve(mouseScenePos, maxDist);
 }
 
 bool XYCurvePrivate::activateCurve(QPointF mouseScenePos, double maxDist) {
 	if (!isVisible())
 		return false;
 
 	int rowCount = 0;
 	if (lineType != XYCurve::LineType::NoLine)
 		rowCount = lines.count();
 	else if (symbolsStyle != Symbol::Style::NoSymbols)
 		rowCount = symbolPointsScene.count();
 	else
 		return false;
 
 	if (rowCount == 0)
 		return false;
 
 	if (maxDist < 0)
 		maxDist = linePen.width() < 10 ? 10: linePen.width();
 
 	double maxDistSquare = pow(maxDist,2);
 
 	int properties = q->xColumn()->properties();
 	if (properties == AbstractColumn::Properties::No) {
 		// assumption: points exist if no line. otherwise previously returned false
 		if (lineType == XYCurve::NoLine) {
 			QPointF curvePosPrevScene = symbolPointsScene[0];
 			QPointF curvePosScene = curvePosPrevScene;
 			for (int row =0; row < rowCount; row ++) {
 				if (pow(mouseScenePos.x() - curvePosScene.x(),2) + pow(mouseScenePos.y() - curvePosScene.y(),2) <= maxDistSquare)
 					return true;
 
 				curvePosPrevScene = curvePosScene;
 				curvePosScene = symbolPointsScene[row];
 			}
 		} else {
 			for (int row=0; row < rowCount; row++) {
 				QLineF line = lines[row];
 				if (pointLiesNearLine(line.p1(), line.p2(), mouseScenePos, maxDist))
 					return true;
 			}
 		}
 
 	} else if (properties == AbstractColumn::Properties::MonotonicIncreasing ||
 			properties == AbstractColumn::Properties::MonotonicDecreasing) {
 
 		bool increase = true;
 		if (properties == AbstractColumn::Properties::MonotonicDecreasing)
 			increase = false;
 
 		double x = mouseScenePos.x()-maxDist;
 		int index = 0;
 
 		QPointF curvePosScene;
 		QPointF curvePosPrevScene;
 
 		if (lineType == XYCurve::NoLine) {
 			curvePosScene  = symbolPointsScene[index];
 			curvePosPrevScene = curvePosScene;
 			index = Column::indexForValue(x, symbolPointsScene, static_cast<AbstractColumn::Properties>(properties));
 		} else
 			index = Column::indexForValue(x, lines, static_cast<AbstractColumn::Properties>(properties));
 
 		if (index >= 1)
 			index --; // use one before so it is secured that I'm before point.x()
 		else if (index == -1)
 			return false;
 
 		double xMaxSquare = mouseScenePos.x() + maxDist;
 		bool stop = false;
 		while (true) {
 			// assumption: points exist if no line. otherwise previously returned false
 			if (lineType == XYCurve::NoLine) {// check points only if no line otherwise check only the lines
 				if (curvePosScene.x() > xMaxSquare)
 					stop = true; // one more time if bigger
 				if (pow(mouseScenePos.x()- curvePosScene.x(),2)+pow(mouseScenePos.y()-curvePosScene.y(),2) <= maxDistSquare)
 					return true;
 			} else {
 				if (lines[index].p1().x() > xMaxSquare)
 					stop = true; // one more time if bigger
 
 				QLineF line = lines[index];
 				if (pointLiesNearLine(line.p1(), line.p2(), mouseScenePos, maxDist))
 					return true;
 			}
 
 			if (stop || (index >= rowCount-1 && increase) || (index <=0 && !increase))
 				break;
 
 			if (increase)
 				index++;
 			else
 				index--;
 
 			if (lineType == XYCurve::NoLine) {
 				curvePosPrevScene = curvePosScene;
 				curvePosScene = symbolPointsScene[index];
 			}
 		}
 	}
 
 	return false;
 }
 
 /*!
  * \brief XYCurve::pointLiesNearLine
  * Calculates if a point \p pos lies near than maxDist to the line created by the points \p p1 and \p p2
  * https://stackoverflow.com/questions/11604680/point-laying-near-line
  * \p p1 first point of the line
  * \p p2 second point of the line
  * \p pos Position to check
  * \p maxDist Maximal distance away from the curve, which is valid
  * \return Return true if point lies next to the line
  */
 bool XYCurvePrivate::pointLiesNearLine(const QPointF p1, const QPointF p2, const QPointF pos, const double maxDist) const{
 	double dx12 = p2.x() - p1.x();
 	double dy12 = p2.y() - p1.y();
 	double vecLenght = sqrt(pow(dx12,2) + pow(dy12,2));
 
 	if (vecLenght == 0) {
 		if (pow(p1.x() - pos.x(), 2) + pow(p1.y()-pos.y(), 2) <= pow(maxDist, 2))
 			return true;
 		 return false;
 	}
 	QPointF unitvec(dx12/vecLenght,dy12/vecLenght);
 
 	double dx1m = pos.x() - p1.x();
 	double dy1m = pos.y() - p1.y();
 
 	double dist_segm = qAbs(dx1m*unitvec.y() - dy1m*unitvec.x());
 	double scalarProduct = dx1m*unitvec.x() + dy1m*unitvec.y();
 
 	if (scalarProduct > 0) {
 		if (scalarProduct < vecLenght && dist_segm < maxDist)
 			return true;
 	}
 	return false;
 }
 
 // TODO: curvePosScene.x() >= mouseScenePos.x() &&
 // curvePosPrevScene.x() < mouseScenePos.x()
 // dürfte eigentlich nicht drin sein
 bool XYCurvePrivate::pointLiesNearCurve(const QPointF mouseScenePos, const QPointF curvePosPrevScene, const QPointF curvePosScene, const int index, const double maxDist) const {
 	if (q->lineType() != XYCurve::LineType::NoLine &&
 			curvePosScene.x() >= mouseScenePos.x() &&
 			curvePosPrevScene.x() < mouseScenePos.x()) {
 
 		if (q->lineType() == XYCurve::LineType::Line) {
 			// point is not in the near of the point, but it can be in the near of the connection line of two points
 			if (pointLiesNearLine(curvePosPrevScene,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		} else if (q->lineType() == XYCurve::LineType::StartHorizontal) {
 			QPointF tempPoint = curvePosPrevScene;
 			tempPoint.setX(curvePosScene.x());
 			if (pointLiesNearLine(curvePosPrevScene,tempPoint, mouseScenePos, maxDist))
 				return true;
 			if (pointLiesNearLine(tempPoint,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		} else if (q->lineType() == XYCurve::LineType::StartVertical) {
 			QPointF tempPoint = curvePosPrevScene;
 			tempPoint.setY(curvePosScene.y());
 			if (pointLiesNearLine(curvePosPrevScene,tempPoint, mouseScenePos, maxDist))
 				return true;
 			if (pointLiesNearLine(tempPoint,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		} else if (q->lineType() == XYCurve::LineType::MidpointHorizontal) {
 			QPointF tempPoint = curvePosPrevScene;
 			tempPoint.setX(curvePosPrevScene.x()+(curvePosScene.x()-curvePosPrevScene.x())/2);
 			if (pointLiesNearLine(curvePosPrevScene,tempPoint, mouseScenePos, maxDist))
 				return true;
 			QPointF tempPoint2(tempPoint.x(), curvePosScene.y());
 			if (pointLiesNearLine(tempPoint,tempPoint2, mouseScenePos, maxDist))
 				return true;
 
 			if (pointLiesNearLine(tempPoint2,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		} else if (q->lineType() == XYCurve::LineType::MidpointVertical) {
 			QPointF tempPoint = curvePosPrevScene;
 			tempPoint.setY(curvePosPrevScene.y()+(curvePosScene.y()-curvePosPrevScene.y())/2);
 			if (pointLiesNearLine(curvePosPrevScene,tempPoint, mouseScenePos, maxDist))
 				return true;
 			QPointF tempPoint2(tempPoint.y(), curvePosScene.x());
 			if (pointLiesNearLine(tempPoint,tempPoint2, mouseScenePos, maxDist))
 				return true;
 
 			if (pointLiesNearLine(tempPoint2,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		} else if (q->lineType() == XYCurve::LineType::SplineAkimaNatural ||
 				   q->lineType() == XYCurve::LineType::SplineCubicNatural ||
 				   q->lineType() == XYCurve::LineType::SplineAkimaPeriodic ||
 				   q->lineType() == XYCurve::LineType::SplineCubicPeriodic) {
 			for (int i=0; i < q->lineInterpolationPointsCount()+1; i++) {
 				QLineF line = lines[index*(q->lineInterpolationPointsCount()+1)+i];
 				QPointF p1 = line.p1(); //cSystem->mapLogicalToScene(line.p1());
 				QPointF p2 = line.p2(); //cSystem->mapLogicalToScene(line.p2());
 				if (pointLiesNearLine(p1, p2, mouseScenePos, maxDist))
 					return true;
 			}
 		} else {
 			// point is not in the near of the point, but it can be in the near of the connection line of two points
 			if (pointLiesNearLine(curvePosPrevScene,curvePosScene, mouseScenePos, maxDist))
 				return true;
 		}
 	}
 	return false;
 }
 
 /*!
  * \brief XYCurve::setHover
  * Will be called in CartesianPlot::hoverMoveEvent()
  * See d->setHover(on) for more documentation
  * \p on
  */
 void XYCurve::setHover(bool on) {
 	Q_D(XYCurve);
 	d->setHover(on);
 }
 
 void XYCurvePrivate::updateErrorBars() {
 	errorBarsPath = QPainterPath();
 	if (xErrorType == XYCurve::NoError && yErrorType == XYCurve::NoError) {
 		recalcShapeAndBoundingRect();
 		return;
 	}
 
 	QVector<QLineF> lines;
 	QVector<QPointF> pointsErrorBarAnchorX;
 	QVector<QPointF> pointsErrorBarAnchorY;
 	float errorPlus, errorMinus;
 
 	for (int i = 0; i < symbolPointsLogical.size(); ++i) {
 		if (!visiblePoints[i])
 			continue;
 
 		const QPointF& point = symbolPointsLogical.at(i);
 		int index = validPointsIndicesLogical.at(i);
 
 		//error bars for x
 		if (xErrorType != XYCurve::NoError) {
 			//determine the values for the errors
 			if (xErrorPlusColumn && xErrorPlusColumn->isValid(index) && !xErrorPlusColumn->isMasked(index))
 				errorPlus = xErrorPlusColumn->valueAt(index);
 			else
 				errorPlus = 0;
 
 			if (xErrorType == XYCurve::SymmetricError)
 				errorMinus = errorPlus;
 			else {
 				if (xErrorMinusColumn && xErrorMinusColumn->isValid(index) && !xErrorMinusColumn->isMasked(index))
 					errorMinus = xErrorMinusColumn->valueAt(index);
 				else
 					errorMinus = 0;
 			}
 
 			//draw the error bars
 			if (errorMinus != 0 || errorPlus !=0)
 				lines.append(QLineF(QPointF(point.x()-errorMinus, point.y()),
 									QPointF(point.x()+errorPlus, point.y())));
 
 			//determine the end points of the errors bars in logical coordinates to draw later the cap
 			if (errorBarsType == XYCurve::ErrorBarsWithEnds) {
 				pointsErrorBarAnchorX << QPointF(point.x() - errorMinus, point.y());
 				pointsErrorBarAnchorX << QPointF(point.x() + errorPlus, point.y());
 			}
 		}
 
 		//error bars for y
 		if (yErrorType != XYCurve::NoError) {
 			//determine the values for the errors
 			if (yErrorPlusColumn && yErrorPlusColumn->isValid(index) && !yErrorPlusColumn->isMasked(index))
 				errorPlus = yErrorPlusColumn->valueAt(index);
 			else
 				errorPlus = 0;
 
 			if (yErrorType == XYCurve::SymmetricError)
 				errorMinus = errorPlus;
 			else {
 				if (yErrorMinusColumn && yErrorMinusColumn->isValid(index) && !yErrorMinusColumn->isMasked(index) )
 					errorMinus = yErrorMinusColumn->valueAt(index);
 				else
 					errorMinus = 0;
 			}
 
 			//draw the error bars
 			if (errorMinus != 0 || errorPlus !=0)
 				lines.append(QLineF(QPointF(point.x(), point.y() + errorMinus),
 									QPointF(point.x(), point.y() - errorPlus)));
 
 			//determine the end points of the errors bars in logical coordinates to draw later the cap
 			if (errorBarsType == XYCurve::ErrorBarsWithEnds) {
 				pointsErrorBarAnchorY << QPointF(point.x(), point.y() + errorMinus);
 				pointsErrorBarAnchorY << QPointF(point.x(), point.y() - errorPlus);
 			}
 		}
 	}
 
 	//map the error bars to scene coordinates
 	lines = cSystem->mapLogicalToScene(lines);
 
 	//new painter path for the error bars
 	for (const auto& line : lines) {
 		errorBarsPath.moveTo(line.p1());
 		errorBarsPath.lineTo(line.p2());
 	}
 
 	//add caps for x error bars
 	if (!pointsErrorBarAnchorX.isEmpty()) {
 		pointsErrorBarAnchorX = cSystem->mapLogicalToScene(pointsErrorBarAnchorX);
 		for (const auto& point : pointsErrorBarAnchorX) {
 			errorBarsPath.moveTo(QPointF(point.x(), point.y() - errorBarsCapSize/2));
 			errorBarsPath.lineTo(QPointF(point.x(), point.y() + errorBarsCapSize/2));
 		}
 	}
 
 	//add caps for y error bars
 	if (!pointsErrorBarAnchorY.isEmpty()) {
 		pointsErrorBarAnchorY = cSystem->mapLogicalToScene(pointsErrorBarAnchorY);
 		for (const auto& point : pointsErrorBarAnchorY) {
 			errorBarsPath.moveTo(QPointF(point.x() - errorBarsCapSize/2, point.y()));
 			errorBarsPath.lineTo(QPointF(point.x() + errorBarsCapSize/2, point.y()));
 		}
 	}
 
 	recalcShapeAndBoundingRect();
 }
 
 /*!
   recalculates the outer bounds and the shape of the curve.
 */
 void XYCurvePrivate::recalcShapeAndBoundingRect() {
 	DEBUG("XYCurvePrivate::recalcShapeAndBoundingRect() m_suppressRecalc = " << m_suppressRecalc);
 	if (m_suppressRecalc)
 		return;
 
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::recalcShapeAndBoundingRect()");
 #endif
 
 	prepareGeometryChange();
 	curveShape = QPainterPath();
 	if (lineType != XYCurve::NoLine)
 		curveShape.addPath(WorksheetElement::shapeFromPath(linePath, linePen));
 
 	if (dropLineType != XYCurve::NoDropLine)
 		curveShape.addPath(WorksheetElement::shapeFromPath(dropLinePath, dropLinePen));
 
 	if (symbolsStyle != Symbol::NoSymbols)
 		curveShape.addPath(symbolsPath);
 
 	if (valuesType != XYCurve::NoValues)
 		curveShape.addPath(valuesPath);
 
 	if (xErrorType != XYCurve::NoError || yErrorType != XYCurve::NoError)
 		curveShape.addPath(WorksheetElement::shapeFromPath(errorBarsPath, errorBarsPen));
 
 	boundingRectangle = curveShape.boundingRect();
 
 	for (const auto& pol : fillPolygons)
 		boundingRectangle = boundingRectangle.united(pol.boundingRect());
 
 	//TODO: when the selection is painted, line intersections are visible.
 	//simplified() removes those artifacts but is horrible slow for curves with large number of points.
 	//search for an alternative.
 	//curveShape = curveShape.simplified();
 
 	updatePixmap();
 }
 
 void XYCurvePrivate::draw(QPainter* painter) {
 #ifdef PERFTRACE_CURVES
 	PERFTRACE(name().toLatin1() + ", XYCurvePrivate::draw()");
 #endif
 
 	//draw filling
 	if (fillingPosition != XYCurve::NoFilling) {
 		painter->setOpacity(fillingOpacity);
 		painter->setPen(Qt::SolidLine);
 		drawFilling(painter);
 	}
 
 	//draw lines
 	if (lineType != XYCurve::NoLine) {
 		painter->setOpacity(lineOpacity);
 		painter->setPen(linePen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(linePath);
 	}
 
 	//draw drop lines
 	if (dropLineType != XYCurve::NoDropLine) {
 		painter->setOpacity(dropLineOpacity);
 		painter->setPen(dropLinePen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(dropLinePath);
 	}
 
 	//draw error bars
 	if ( (xErrorType != XYCurve::NoError) || (yErrorType != XYCurve::NoError) ) {
 		painter->setOpacity(errorBarsOpacity);
 		painter->setPen(errorBarsPen);
 		painter->setBrush(Qt::NoBrush);
 		painter->drawPath(errorBarsPath);
 	}
 
 	//draw symbols
 	if (symbolsStyle != Symbol::NoSymbols) {
 		painter->setOpacity(symbolsOpacity);
 		painter->setPen(symbolsPen);
 		painter->setBrush(symbolsBrush);
 		drawSymbols(painter);
 	}
 
 	//draw values
 	if (valuesType != XYCurve::NoValues) {
 		painter->setOpacity(valuesOpacity);
 		//don't use any painter pen, since this will force QPainter to render the text outline which is expensive
 		painter->setPen(Qt::NoPen);
 		painter->setBrush(valuesColor);
 		drawValues(painter);
 	}
 }
 
 void XYCurvePrivate::updatePixmap() {
 	DEBUG("XYCurvePrivate::updatePixmap() m_suppressRecalc = " << m_suppressRecalc);
 	if (m_suppressRecalc)
 		return;
 
 	WAIT_CURSOR;
 
 	m_hoverEffectImageIsDirty = true;
 	m_selectionEffectImageIsDirty = true;
 	if (boundingRectangle.width() == 0 || boundingRectangle.height() == 0) {
 		DEBUG("	boundingRectangle.width() or boundingRectangle.height() == 0");
 		m_pixmap = QPixmap();
 		RESET_CURSOR;
 		return;
 	}
 	QPixmap pixmap(ceil(boundingRectangle.width()), ceil(boundingRectangle.height()));
 	pixmap.fill(Qt::transparent);
 	QPainter painter(&pixmap);
 	painter.setRenderHint(QPainter::Antialiasing, true);
 	painter.translate(-boundingRectangle.topLeft());
 
 	draw(&painter);
 	painter.end();
 	m_pixmap = pixmap;
 
 	update();
 	RESET_CURSOR;
 }
 
 /*!
   Reimplementation of QGraphicsItem::paint(). This function does the actual painting of the curve.
   \sa QGraphicsItem::paint().
 */
 void XYCurvePrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option);
 	Q_UNUSED(widget);
 	if (!isVisible())
 		return;
 
 	painter->setPen(Qt::NoPen);
 	painter->setBrush(Qt::NoBrush);
 	painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
 	if ( KSharedConfig::openConfig()->group("Settings_Worksheet").readEntry<bool>("DoubleBuffering", true) )
 		painter->drawPixmap(boundingRectangle.topLeft(), m_pixmap); //draw the cached pixmap (fast)
 	else
 		draw(painter); //draw directly again (slow)
 
 
 	if (m_hovered && !isSelected() && !m_printing) {
 		if (m_hoverEffectImageIsDirty) {
 			QPixmap pix = m_pixmap;
 			QPainter p(&pix);
 			p.setCompositionMode(QPainter::CompositionMode_SourceIn);	// source (shadow) pixels merged with the alpha channel of the destination (m_pixmap)
 			p.fillRect(pix.rect(), QApplication::palette().color(QPalette::Shadow));
 			p.end();
 
 			m_hoverEffectImage = ImageTools::blurred(pix.toImage(), m_pixmap.rect(), 5);
 			m_hoverEffectImageIsDirty = false;
 		}
 
 		painter->drawImage(boundingRectangle.topLeft(), m_hoverEffectImage, m_pixmap.rect());
 		return;
 	}
 
 	if (isSelected() && !m_printing) {
 		if (m_selectionEffectImageIsDirty) {
 			QPixmap pix = m_pixmap;
 			QPainter p(&pix);
 			p.setCompositionMode(QPainter::CompositionMode_SourceIn);
 			p.fillRect(pix.rect(), QApplication::palette().color(QPalette::Highlight));
 			p.end();
 
 			m_selectionEffectImage = ImageTools::blurred(pix.toImage(), m_pixmap.rect(), 5);
 			m_selectionEffectImageIsDirty = false;
 		}
 
 		painter->drawImage(boundingRectangle.topLeft(), m_selectionEffectImage, m_pixmap.rect());
 	}
 }
 
 /*!
 	Drawing of symbolsPath is very slow, so we draw every symbol in the loop which is much faster (factor 10)
 */
 void XYCurvePrivate::drawSymbols(QPainter* painter) {
 	QPainterPath path = Symbol::pathFromStyle(symbolsStyle);
 
 	QTransform trafo;
 	trafo.scale(symbolsSize, symbolsSize);
 	path = trafo.map(path);
 	trafo.reset();
 	if (symbolsRotationAngle != 0) {
 		trafo.rotate(-symbolsRotationAngle);
 		path = trafo.map(path);
 	}
 	for (const auto& point : symbolPointsScene) {
 		trafo.reset();
 		trafo.translate(point.x(), point.y());
 		painter->drawPath(trafo.map(path));
 	}
 }
 
 void XYCurvePrivate::drawValues(QPainter* painter) {
 	QTransform trafo;
 	QPainterPath path;
 	for (int i = 0; i < valuesPoints.size(); i++) {
 		path = QPainterPath();
 		path.addText( QPoint(0,0), valuesFont, valuesStrings.at(i) );
 
 		trafo.reset();
 		trafo.translate( valuesPoints.at(i).x(), valuesPoints.at(i).y() );
 		if (valuesRotationAngle != 0)
 			trafo.rotate( -valuesRotationAngle );
 
 		painter->drawPath(trafo.map(path));
 	}
 }
 
 void XYCurvePrivate::drawFilling(QPainter* painter) {
 	for (const auto& pol : fillPolygons) {
 		QRectF rect = pol.boundingRect();
 		if (fillingType == PlotArea::Color) {
 			switch (fillingColorStyle) {
 			case PlotArea::SingleColor: {
 					painter->setBrush(QBrush(fillingFirstColor));
 					break;
 				}
 			case PlotArea::HorizontalLinearGradient: {
 					QLinearGradient linearGrad(rect.topLeft(), rect.topRight());
 					linearGrad.setColorAt(0, fillingFirstColor);
 					linearGrad.setColorAt(1, fillingSecondColor);
 					painter->setBrush(QBrush(linearGrad));
 					break;
 				}
 			case PlotArea::VerticalLinearGradient: {
 					QLinearGradient linearGrad(rect.topLeft(), rect.bottomLeft());
 					linearGrad.setColorAt(0, fillingFirstColor);
 					linearGrad.setColorAt(1, fillingSecondColor);
 					painter->setBrush(QBrush(linearGrad));
 					break;
 				}
 			case PlotArea::TopLeftDiagonalLinearGradient: {
 					QLinearGradient linearGrad(rect.topLeft(), rect.bottomRight());
 					linearGrad.setColorAt(0, fillingFirstColor);
 					linearGrad.setColorAt(1, fillingSecondColor);
 					painter->setBrush(QBrush(linearGrad));
 					break;
 				}
 			case PlotArea::BottomLeftDiagonalLinearGradient: {
 					QLinearGradient linearGrad(rect.bottomLeft(), rect.topRight());
 					linearGrad.setColorAt(0, fillingFirstColor);
 					linearGrad.setColorAt(1, fillingSecondColor);
 					painter->setBrush(QBrush(linearGrad));
 					break;
 				}
 			case PlotArea::RadialGradient: {
 					QRadialGradient radialGrad(rect.center(), rect.width()/2);
 					radialGrad.setColorAt(0, fillingFirstColor);
 					radialGrad.setColorAt(1, fillingSecondColor);
 					painter->setBrush(QBrush(radialGrad));
 					break;
 				}
 			}
 		} else if (fillingType == PlotArea::Image) {
 			if ( !fillingFileName.trimmed().isEmpty() ) {
 				QPixmap pix(fillingFileName);
 				switch (fillingImageStyle) {
 				case PlotArea::ScaledCropped:
 					pix = pix.scaled(rect.size().toSize(), Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2, pix.size().height()/2);
 					break;
 				case PlotArea::Scaled:
 					pix = pix.scaled(rect.size().toSize(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2, pix.size().height()/2);
 					break;
 				case PlotArea::ScaledAspectRatio:
 					pix = pix.scaled(rect.size().toSize(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2, pix.size().height()/2);
 					break;
 				case PlotArea::Centered: {
 						QPixmap backpix(rect.size().toSize());
 						backpix.fill();
 						QPainter p(&backpix);
 						p.drawPixmap(QPointF(0, 0), pix);
 						p.end();
 						painter->setBrush(QBrush(backpix));
 						painter->setBrushOrigin(-pix.size().width()/2, -pix.size().height()/2);
 						break;
 					}
 				case PlotArea::Tiled:
 					painter->setBrush(QBrush(pix));
 					break;
 				case PlotArea::CenterTiled:
 					painter->setBrush(QBrush(pix));
 					painter->setBrushOrigin(pix.size().width()/2, pix.size().height()/2);
 				}
 			}
 		} else if (fillingType == PlotArea::Pattern)
 			painter->setBrush(QBrush(fillingFirstColor, fillingBrushStyle));
 
 		painter->drawPolygon(pol);
 	}
 }
 
 void XYCurvePrivate::setPrinting(bool on) {
 	m_printing = on;
 }
 
 void XYCurvePrivate::suppressRetransform(bool on) {
 	m_suppressRetransform = on;
 	m_suppressRecalc = on;
 }
 
 /*!
  * \brief XYCurvePrivate::mousePressEvent
  * checks with activateCurve, if the mousePress was in the near
  * of the curve. If it was, the curve will be selected
  * \p event
  */
 void XYCurvePrivate::mousePressEvent(QGraphicsSceneMouseEvent* event) {
 	if (plot->mouseMode() != CartesianPlot::MouseMode::SelectionMode) {
 		event->ignore();
 		return QGraphicsItem::mousePressEvent(event);
 	}
 
 	if(q->activateCurve(event->pos())){
 		setSelected(true);
 		return;
 	}
 
 	event->ignore();
 	setSelected(false);
 	QGraphicsItem::mousePressEvent(event);
 }
 
 /*!
  * \brief XYCurvePrivate::setHover
  * Will be called from CartesianPlot::hoverMoveEvent which
  * determines, which curve is hovered
  * \p on
  */
 void XYCurvePrivate::setHover(bool on) {
 	if(on == m_hovered)
 		return; // don't update if state not changed
 
 	m_hovered = on;
 	on ? emit q->hovered() : emit q->unhovered();
 	update();
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void XYCurve::save(QXmlStreamWriter* writer) const {
 	Q_D(const XYCurve);
 
 	writer->writeStartElement( "xyCurve" );
 	writeBasicAttributes( writer );
 	writeCommentElement( writer );
 
 	//general
 	writer->writeStartElement( "general" );
 	WRITE_COLUMN(d->xColumn, xColumn);
 	WRITE_COLUMN(d->yColumn, yColumn);
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//Line
 	writer->writeStartElement( "lines" );
 	writer->writeAttribute( "type", QString::number(d->lineType) );
 	writer->writeAttribute( "skipGaps", QString::number(d->lineSkipGaps) );
 	writer->writeAttribute( "increasingXOnly", QString::number(d->lineIncreasingXOnly) );
 	writer->writeAttribute( "interpolationPointsCount", QString::number(d->lineInterpolationPointsCount) );
 	WRITE_QPEN(d->linePen);
 	writer->writeAttribute( "opacity", QString::number(d->lineOpacity) );
 	writer->writeEndElement();
 
 	//Drop lines
 	writer->writeStartElement( "dropLines" );
 	writer->writeAttribute( "type", QString::number(d->dropLineType) );
 	WRITE_QPEN(d->dropLinePen);
 	writer->writeAttribute( "opacity", QString::number(d->dropLineOpacity) );
 	writer->writeEndElement();
 
 	//Symbols
 	writer->writeStartElement( "symbols" );
 	writer->writeAttribute( "symbolsStyle", QString::number(d->symbolsStyle) );
 	writer->writeAttribute( "opacity", QString::number(d->symbolsOpacity) );
 	writer->writeAttribute( "rotation", QString::number(d->symbolsRotationAngle) );
 	writer->writeAttribute( "size", QString::number(d->symbolsSize) );
 	WRITE_QBRUSH(d->symbolsBrush);
 	WRITE_QPEN(d->symbolsPen);
 	writer->writeEndElement();
 
 	//Values
 	writer->writeStartElement( "values" );
 	writer->writeAttribute( "type", QString::number(d->valuesType) );
 	WRITE_COLUMN(d->valuesColumn, valuesColumn);
 	writer->writeAttribute( "position", QString::number(d->valuesPosition) );
 	writer->writeAttribute( "distance", QString::number(d->valuesDistance) );
 	writer->writeAttribute( "rotation", QString::number(d->valuesRotationAngle) );
 	writer->writeAttribute( "opacity", QString::number(d->valuesOpacity) );
 	//TODO values format and precision
 	writer->writeAttribute( "prefix", d->valuesPrefix );
 	writer->writeAttribute( "suffix", d->valuesSuffix );
 	WRITE_QCOLOR(d->valuesColor);
 	WRITE_QFONT(d->valuesFont);
 	writer->writeEndElement();
 
 	//Filling
 	writer->writeStartElement( "filling" );
 	writer->writeAttribute( "position", QString::number(d->fillingPosition) );
 	writer->writeAttribute( "type", QString::number(d->fillingType) );
 	writer->writeAttribute( "colorStyle", QString::number(d->fillingColorStyle) );
 	writer->writeAttribute( "imageStyle", QString::number(d->fillingImageStyle) );
 	writer->writeAttribute( "brushStyle", QString::number(d->fillingBrushStyle) );
 	writer->writeAttribute( "firstColor_r", QString::number(d->fillingFirstColor.red()) );
 	writer->writeAttribute( "firstColor_g", QString::number(d->fillingFirstColor.green()) );
 	writer->writeAttribute( "firstColor_b", QString::number(d->fillingFirstColor.blue()) );
 	writer->writeAttribute( "secondColor_r", QString::number(d->fillingSecondColor.red()) );
 	writer->writeAttribute( "secondColor_g", QString::number(d->fillingSecondColor.green()) );
 	writer->writeAttribute( "secondColor_b", QString::number(d->fillingSecondColor.blue()) );
 	writer->writeAttribute( "fileName", d->fillingFileName );
 	writer->writeAttribute( "opacity", QString::number(d->fillingOpacity) );
 	writer->writeEndElement();
 
 	//Error bars
 	writer->writeStartElement( "errorBars" );
 	writer->writeAttribute( "xErrorType", QString::number(d->xErrorType) );
 	WRITE_COLUMN(d->xErrorPlusColumn, xErrorPlusColumn);
 	WRITE_COLUMN(d->xErrorMinusColumn, xErrorMinusColumn);
 	writer->writeAttribute( "yErrorType", QString::number(d->yErrorType) );
 	WRITE_COLUMN(d->yErrorPlusColumn, yErrorPlusColumn);
 	WRITE_COLUMN(d->yErrorMinusColumn, yErrorMinusColumn);
 	writer->writeAttribute( "type", QString::number(d->errorBarsType) );
 	writer->writeAttribute( "capSize", QString::number(d->errorBarsCapSize) );
 	WRITE_QPEN(d->errorBarsPen);
 	writer->writeAttribute( "opacity", QString::number(d->errorBarsOpacity) );
 	writer->writeEndElement();
 
 	writer->writeEndElement(); //close "xyCurve" section
 }
 
 //! Load from XML
 bool XYCurve::load(XmlStreamReader* reader, bool preview) {
 	Q_D(XYCurve);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "xyCurve")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (reader->name() == "general") {
 			attribs = reader->attributes();
 			READ_COLUMN(xColumn);
 			READ_COLUMN(yColumn);
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (!preview && reader->name() == "lines") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", lineType, XYCurve::LineType);
 			READ_INT_VALUE("skipGaps", lineSkipGaps, bool);
 			READ_INT_VALUE("increasingXOnly", lineIncreasingXOnly, bool);
 			READ_INT_VALUE("interpolationPointsCount", lineInterpolationPointsCount, int);
 			READ_QPEN(d->linePen);
 			READ_DOUBLE_VALUE("opacity", lineOpacity);
 		} else if (!preview && reader->name() == "dropLines") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", dropLineType, XYCurve::DropLineType);
 			READ_QPEN(d->dropLinePen);
 			READ_DOUBLE_VALUE("opacity", dropLineOpacity);
 
 		} else if (!preview && reader->name() == "symbols") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("symbolsStyle", symbolsStyle, Symbol::Style);
 			READ_DOUBLE_VALUE("opacity", symbolsOpacity);
 			READ_DOUBLE_VALUE("rotation", symbolsRotationAngle);
 			READ_DOUBLE_VALUE("size", symbolsSize);
 
 			READ_QBRUSH(d->symbolsBrush);
 			READ_QPEN(d->symbolsPen);
 		} else if (!preview && reader->name() == "values") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("type", valuesType, XYCurve::ValuesType);
 			READ_COLUMN(valuesColumn);
 
 			READ_INT_VALUE("position", valuesPosition, XYCurve::ValuesPosition);
 			READ_DOUBLE_VALUE("distance", valuesDistance);
 			READ_DOUBLE_VALUE("rotation", valuesRotationAngle);
 			READ_DOUBLE_VALUE("opacity", valuesOpacity);
 
 			//don't produce any warning if no prefix or suffix is set (empty string is allowed here in xml)
 			d->valuesPrefix = attribs.value("prefix").toString();
 			d->valuesSuffix = attribs.value("suffix").toString();
 
 			READ_QCOLOR(d->valuesColor);
 			READ_QFONT(d->valuesFont);
 		} else if (!preview && reader->name() == "filling") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("position", fillingPosition, XYCurve::FillingPosition);
 			READ_INT_VALUE("type", fillingType, PlotArea::BackgroundType);
 			READ_INT_VALUE("colorStyle", fillingColorStyle, PlotArea::BackgroundColorStyle);
 			READ_INT_VALUE("imageStyle", fillingImageStyle, PlotArea::BackgroundImageStyle );
 			READ_INT_VALUE("brushStyle", fillingBrushStyle, Qt::BrushStyle);
 
 			str = attribs.value("firstColor_r").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_r").toString());
 			else
 				d->fillingFirstColor.setRed(str.toInt());
 
 			str = attribs.value("firstColor_g").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_g").toString());
 			else
 				d->fillingFirstColor.setGreen(str.toInt());
 
 			str = attribs.value("firstColor_b").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("firstColor_b").toString());
 			else
 				d->fillingFirstColor.setBlue(str.toInt());
 
 			str = attribs.value("secondColor_r").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_r").toString());
 			else
 				d->fillingSecondColor.setRed(str.toInt());
 
 			str = attribs.value("secondColor_g").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_g").toString());
 			else
 				d->fillingSecondColor.setGreen(str.toInt());
 
 			str = attribs.value("secondColor_b").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("secondColor_b").toString());
 			else
 				d->fillingSecondColor.setBlue(str.toInt());
 
 			READ_STRING_VALUE("fileName", fillingFileName);
 			READ_DOUBLE_VALUE("opacity", fillingOpacity);
 		} else if (!preview && reader->name() == "errorBars") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("xErrorType", xErrorType, XYCurve::ErrorType);
 			READ_COLUMN(xErrorPlusColumn);
 			READ_COLUMN(xErrorMinusColumn);
 
 			READ_INT_VALUE("yErrorType", yErrorType, XYCurve::ErrorType);
 			READ_COLUMN(yErrorPlusColumn);
 			READ_COLUMN(yErrorMinusColumn);
 
 			READ_INT_VALUE("type", errorBarsType, XYCurve::ErrorBarsType);
 			READ_DOUBLE_VALUE("capSize", errorBarsCapSize);
 
 			READ_QPEN(d->errorBarsPen);
 
 			READ_DOUBLE_VALUE("opacity", errorBarsOpacity);
 		}
 	}
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void XYCurve::loadThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("XYCurve");
 
 	int index = parentAspect()->indexOfChild<XYCurve>(this);
 	const auto* plot = dynamic_cast<const CartesianPlot*>(parentAspect());
 	QColor themeColor;
 	if (index<plot->themeColorPalette().size())
 		themeColor = plot->themeColorPalette().at(index);
 	else {
 		if (plot->themeColorPalette().size())
 			themeColor = plot->themeColorPalette().last();
 	}
 
 	QPen p;
 
 	Q_D(XYCurve);
 	d->m_suppressRecalc = true;
 
 	//Line
-	p.setStyle((Qt::PenStyle)group.readEntry("LineStyle", (int)this->linePen().style()));
-	p.setWidthF(group.readEntry("LineWidth", this->linePen().widthF()));
+	p.setStyle((Qt::PenStyle)group.readEntry("LineStyle", (int)Qt::SolidLine));
+	p.setWidthF(group.readEntry("LineWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	p.setColor(themeColor);
 	this->setLinePen(p);
-	this->setLineOpacity(group.readEntry("LineOpacity", this->lineOpacity()));
+	this->setLineOpacity(group.readEntry("LineOpacity", 1.0));
 
 	//Drop line
-	p.setStyle((Qt::PenStyle)group.readEntry("DropLineStyle",(int) this->dropLinePen().style()));
-	p.setWidthF(group.readEntry("DropLineWidth", this->dropLinePen().widthF()));
+	p.setStyle((Qt::PenStyle)group.readEntry("DropLineStyle", (int)Qt::SolidLine));
+	p.setWidthF(group.readEntry("DropLineWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	p.setColor(themeColor);
 	this->setDropLinePen(p);
-	this->setDropLineOpacity(group.readEntry("DropLineOpacity", this->dropLineOpacity()));
+	this->setDropLineOpacity(group.readEntry("DropLineOpacity", 1.0));
 
 	//Symbol
-	this->setSymbolsOpacity(group.readEntry("SymbolOpacity", this->symbolsOpacity()));
-	QBrush brush = symbolsBrush();
+	this->setSymbolsOpacity(group.readEntry("SymbolOpacity", 1.0));
+	QBrush brush;
+	brush.setStyle((Qt::BrushStyle)group.readEntry("SymbolFillingStyle", (int)Qt::SolidPattern));
 	brush.setColor(themeColor);
 	this->setSymbolsBrush(brush);
-	p = symbolsPen();
+	p.setStyle((Qt::PenStyle)group.readEntry("SymbolBorderStyle", (int)Qt::SolidLine));
 	p.setColor(themeColor);
+	p.setWidthF(group.readEntry("SymbolBorderWidth", Worksheet::convertToSceneUnits(0.0, Worksheet::Point)));
 	this->setSymbolsPen(p);
 
 	//Values
-	this->setValuesOpacity(group.readEntry("ValuesOpacity", this->valuesOpacity()));
-	this->setValuesColor(group.readEntry("ValuesColor", this->valuesColor()));
+	this->setValuesOpacity(group.readEntry("ValuesOpacity", 1.0));
+	this->setValuesColor(group.readEntry("ValuesColor", QColor(Qt::black)));
 
 	//Filling
-	this->setFillingBrushStyle((Qt::BrushStyle)group.readEntry("FillingBrushStyle",(int) this->fillingBrushStyle()));
-	this->setFillingColorStyle((PlotArea::BackgroundColorStyle)group.readEntry("FillingColorStyle",(int) this->fillingColorStyle()));
-	this->setFillingOpacity(group.readEntry("FillingOpacity", this->fillingOpacity()));
-	this->setFillingPosition((XYCurve::FillingPosition)group.readEntry("FillingPosition",(int) this->fillingPosition()));
-	this->setFillingSecondColor(group.readEntry("FillingSecondColor",(QColor) this->fillingSecondColor()));
+	this->setFillingBrushStyle((Qt::BrushStyle)group.readEntry("FillingBrushStyle", (int)Qt::SolidPattern));
+	this->setFillingColorStyle((PlotArea::BackgroundColorStyle)group.readEntry("FillingColorStyle", (int)PlotArea::SingleColor));
+	this->setFillingOpacity(group.readEntry("FillingOpacity", 1.0));
+	this->setFillingPosition((XYCurve::FillingPosition)group.readEntry("FillingPosition", (int)XYCurve::NoFilling));
 	this->setFillingFirstColor(themeColor);
-	this->setFillingType((PlotArea::BackgroundType)group.readEntry("FillingType",(int) this->fillingType()));
+	this->setFillingSecondColor(group.readEntry("FillingSecondColor", QColor(Qt::black)));
+	this->setFillingType((PlotArea::BackgroundType)group.readEntry("FillingType", (int)PlotArea::Color));
 
 	//Error Bars
-	p.setStyle((Qt::PenStyle)group.readEntry("ErrorBarsStyle",(int) this->errorBarsPen().style()));
-	p.setWidthF(group.readEntry("ErrorBarsWidth", this->errorBarsPen().widthF()));
+	p.setStyle((Qt::PenStyle)group.readEntry("ErrorBarsStyle", (int)Qt::SolidLine));
+	p.setWidthF(group.readEntry("ErrorBarsWidth", Worksheet::convertToSceneUnits(1.0, Worksheet::Point)));
 	p.setColor(themeColor);
 	this->setErrorBarsPen(p);
-	this->setErrorBarsOpacity(group.readEntry("ErrorBarsOpacity",this->errorBarsOpacity()));
+	this->setErrorBarsOpacity(group.readEntry("ErrorBarsOpacity", 1.0));
 
 	d->m_suppressRecalc = false;
 	d->recalcShapeAndBoundingRect();
 }
 
 void XYCurve::saveThemeConfig(const KConfig& config) {
 	KConfigGroup group = config.group("XYCurve");
 
 	//Drop line
 	group.writeEntry("DropLineColor",(QColor) this->dropLinePen().color());
 	group.writeEntry("DropLineStyle",(int) this->dropLinePen().style());
 	group.writeEntry("DropLineWidth", this->dropLinePen().widthF());
 	group.writeEntry("DropLineOpacity",this->dropLineOpacity());
 
 	//Error Bars
 	group.writeEntry("ErrorBarsCapSize",this->errorBarsCapSize());
 	group.writeEntry("ErrorBarsOpacity",this->errorBarsOpacity());
 	group.writeEntry("ErrorBarsColor",(QColor) this->errorBarsPen().color());
 	group.writeEntry("ErrorBarsStyle",(int) this->errorBarsPen().style());
 	group.writeEntry("ErrorBarsWidth", this->errorBarsPen().widthF());
 
 	//Filling
 	group.writeEntry("FillingBrushStyle",(int) this->fillingBrushStyle());
 	group.writeEntry("FillingColorStyle",(int) this->fillingColorStyle());
 	group.writeEntry("FillingOpacity", this->fillingOpacity());
 	group.writeEntry("FillingPosition",(int) this->fillingPosition());
 	group.writeEntry("FillingSecondColor",(QColor) this->fillingSecondColor());
 	group.writeEntry("FillingType",(int) this->fillingType());
 
 	//Line
 	group.writeEntry("LineOpacity", this->lineOpacity());
 	group.writeEntry("LineStyle",(int) this->linePen().style());
 	group.writeEntry("LineWidth", this->linePen().widthF());
 
 	//Symbol
 	group.writeEntry("SymbolOpacity", this->symbolsOpacity());
 
 	//Values
 	group.writeEntry("ValuesOpacity", this->valuesOpacity());
 	group.writeEntry("ValuesColor", (QColor) this->valuesColor());
 	group.writeEntry("ValuesFont", this->valuesFont());
 
 	int index = parentAspect()->indexOfChild<XYCurve>(this);
 	if (index < 5) {
 		KConfigGroup themeGroup = config.group("Theme");
 		for (int i = index; i<5; i++) {
 			QString s = "ThemePaletteColor" + QString::number(i+1);
 			themeGroup.writeEntry(s,(QColor) this->linePen().color());
 		}
 	}
 }