diff --git a/src/backend/worksheet/Image.cpp b/src/backend/worksheet/Image.cpp
index b4e2a3284..f2310eb94 100644
--- a/src/backend/worksheet/Image.cpp
+++ b/src/backend/worksheet/Image.cpp
@@ -1,668 +1,668 @@
 /***************************************************************************
     File                 : Image.cpp
     Project              : LabPlot
     Description          : Worksheet element to draw images
     --------------------------------------------------------------------
     Copyright            : (C) 2019 Alexander Semke (alexander.semke@web.de)
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "Image.h"
 #include "Worksheet.h"
 #include "ImagePrivate.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/XmlStreamReader.h"
 
 // #include <QApplication>
 #include <QPainter>
 #include <QGraphicsScene>
 #include <QGraphicsSceneMouseEvent>
 #include <QMenu>
 
 #include <QIcon>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 /**
  * \class Image
  * \brief A label supporting rendering of html- and tex-formatted texts.
  *
  * The label is aligned relative to the specified position.
  * The position can be either specified by providing the x- and y- coordinates
  * in parent's coordinate system, or by specifying one of the predefined position
  * flags (\ca HorizontalPosition, \ca VerticalPosition).
  */
 
 
 Image::Image(const QString& name)
 	: WorksheetElement(name, AspectType::Image), d_ptr(new ImagePrivate(this)) {
 
 	init();
 }
 
 Image::Image(const QString &name, ImagePrivate *dd)
 	: WorksheetElement(name, AspectType::Image), d_ptr(dd) {
 
 	init();
 }
 
 void Image::init() {
 	Q_D(Image);
 
 	KConfig config;
 	KConfigGroup group = config.group("Image");
 
 	d->opacity = group.readEntry("opacity", d->opacity);
 
 	//geometry
 	d->position.point.setX( group.readEntry("PositionXValue", d->position.point.x()) );
 	d->position.point.setY( group.readEntry("PositionYValue", d->position.point.y()) );
 	d->position.horizontalPosition = (WorksheetElement::HorizontalPosition) group.readEntry("PositionX", (int)d->position.horizontalPosition);
 	d->position.verticalPosition = (WorksheetElement::VerticalPosition) group.readEntry("PositionY", (int)d->position.verticalPosition);
 	d->horizontalAlignment = (WorksheetElement::HorizontalAlignment) group.readEntry("HorizontalAlignment", (int)d->horizontalAlignment);
 	d->verticalAlignment = (WorksheetElement::VerticalAlignment) group.readEntry("VerticalAlignment", (int)d->verticalAlignment);
 	d->rotationAngle = group.readEntry("Rotation", d->rotationAngle);
 
 	//border
 	d->borderPen = QPen(group.readEntry("BorderColor", d->borderPen.color()),
 						group.readEntry("BorderWidth", d->borderPen.width()),
 						(Qt::PenStyle) group.readEntry("BorderStyle", (int)(d->borderPen.style())));
 	d->borderOpacity = group.readEntry("BorderOpacity", d->borderOpacity);
 }
 
 //no need to delete the d-pointer here - it inherits from QGraphicsItem
 //and is deleted during the cleanup in QGraphicsScene
 Image::~Image() = default;
 
 QGraphicsItem* Image::graphicsItem() const {
 	return d_ptr;
 }
 
 void Image::setParentGraphicsItem(QGraphicsItem* item) {
 	Q_D(Image);
 	d->setParentItem(item);
 	d->updatePosition();
 }
 
 void Image::retransform() {
 	Q_D(Image);
 	d->retransform();
 }
 
 void Image::handleResize(double horizontalRatio, double verticalRatio, bool pageResize) {
 	DEBUG("Image::handleResize()");
 	Q_UNUSED(pageResize);
 	Q_D(Image);
 
 // 	double ratio = 0;
 // 	if (horizontalRatio > 1.0 || verticalRatio > 1.0)
 // 		ratio = qMax(horizontalRatio, verticalRatio);
 // 	else
 // 		ratio = qMin(horizontalRatio, verticalRatio);
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon Image::icon() const{
-	return QIcon::fromTheme("draw-image");
+	return QIcon::fromTheme("viewimage");
 }
 
 QMenu* Image::createContextMenu() {
 	QMenu *menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1); //skip the first action because of the "title-action"
 
 	if (!visibilityAction) {
 		visibilityAction = new QAction(i18n("Visible"), this);
 		visibilityAction->setCheckable(true);
 		connect(visibilityAction, &QAction::triggered, this, &Image::visibilityChanged);
 	}
 
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 	menu->insertSeparator(firstAction);
 
 	return menu;
 }
 
 /* ============================ getter methods ================= */
 CLASS_SHARED_D_READER_IMPL(Image, QString, fileName, fileName)
 CLASS_SHARED_D_READER_IMPL(Image, WorksheetElement::PositionWrapper, position, position)
 BASIC_SHARED_D_READER_IMPL(Image, WorksheetElement::HorizontalAlignment, horizontalAlignment, horizontalAlignment)
 BASIC_SHARED_D_READER_IMPL(Image, WorksheetElement::VerticalAlignment, verticalAlignment, verticalAlignment)
 BASIC_SHARED_D_READER_IMPL(Image, qreal, rotationAngle, rotationAngle)
 
 CLASS_SHARED_D_READER_IMPL(Image, QPen, borderPen, borderPen)
 BASIC_SHARED_D_READER_IMPL(Image, qreal, borderOpacity, borderOpacity)
 
 /* ============================ setter methods and undo commands ================= */
 STD_SETTER_CMD_IMPL_F_S(Image, SetFileName, QString, fileName, updateImage)
 void Image::setFileName(const QString& fileName) {
 	Q_D(Image);
 	if (fileName != d->fileName)
 		exec(new ImageSetFileNameCmd(d, fileName, ki18n("%1: set image")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetOpacity, qreal, opacity, update)
 void Image::setOpacity(qreal opacity) {
 	Q_D(Image);
 	if (opacity != d->opacity)
 		exec(new ImageSetOpacityCmd(d, opacity, ki18n("%1: set border opacity")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetPosition, WorksheetElement::PositionWrapper, position, retransform);
 void Image::setPosition(const WorksheetElement::PositionWrapper& pos) {
 	Q_D(Image);
 	if (pos.point != d->position.point || pos.horizontalPosition != d->position.horizontalPosition || pos.verticalPosition != d->position.verticalPosition)
 		exec(new ImageSetPositionCmd(d, pos, ki18n("%1: set position")));
 }
 
 /*!
 	sets the position without undo/redo-stuff
 */
 void Image::setPosition(QPointF point) {
 	Q_D(Image);
 	if (point != d->position.point) {
 		d->position.point = point;
 		retransform();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetRotationAngle, qreal, rotationAngle, recalcShapeAndBoundingRect);
 void Image::setRotationAngle(qreal angle) {
 	Q_D(Image);
 	if (angle != d->rotationAngle)
 		exec(new ImageSetRotationAngleCmd(d, angle, ki18n("%1: set rotation angle")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetHorizontalAlignment, WorksheetElement::HorizontalAlignment, horizontalAlignment, retransform);
 void Image::setHorizontalAlignment(const WorksheetElement::HorizontalAlignment hAlign) {
 	Q_D(Image);
 	if (hAlign != d->horizontalAlignment)
 		exec(new ImageSetHorizontalAlignmentCmd(d, hAlign, ki18n("%1: set horizontal alignment")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetVerticalAlignment, WorksheetElement::VerticalAlignment, verticalAlignment, retransform);
 void Image::setVerticalAlignment(const WorksheetElement::VerticalAlignment vAlign) {
 	Q_D(Image);
 	if (vAlign != d->verticalAlignment)
 		exec(new ImageSetVerticalAlignmentCmd(d, vAlign, ki18n("%1: set vertical alignment")));
 }
 
 //Border
 STD_SETTER_CMD_IMPL_F_S(Image, SetBorderPen, QPen, borderPen, update)
 void Image::setBorderPen(const QPen &pen) {
 	Q_D(Image);
 	if (pen != d->borderPen)
 		exec(new ImageSetBorderPenCmd(d, pen, ki18n("%1: set border")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(Image, SetBorderOpacity, qreal, borderOpacity, update)
 void Image::setBorderOpacity(qreal opacity) {
 	Q_D(Image);
 	if (opacity != d->borderOpacity)
 		exec(new ImageSetBorderOpacityCmd(d, opacity, ki18n("%1: set border opacity")));
 }
 
 //misc
 STD_SWAP_METHOD_SETTER_CMD_IMPL_F(Image, SetVisible, bool, swapVisible, retransform);
 void Image::setVisible(bool on) {
 	Q_D(Image);
 	exec(new ImageSetVisibleCmd(d, on, on ? ki18n("%1: set visible") : ki18n("%1: set invisible")));
 }
 
 bool Image::isVisible() const {
 	Q_D(const Image);
 	return d->isVisible();
 }
 
 void Image::setPrinting(bool on) {
 	Q_D(Image);
 	d->m_printing = on;
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void Image::visibilityChanged() {
 	Q_D(const Image);
 	this->setVisible(!d->isVisible());
 }
 
 //##############################################################################
 //####################### Private implementation ###############################
 //##############################################################################
 ImagePrivate::ImagePrivate(Image* owner) : q(owner) {
 	setFlag(QGraphicsItem::ItemIsSelectable);
 	setFlag(QGraphicsItem::ItemIsMovable);
 	setFlag(QGraphicsItem::ItemSendsGeometryChanges);
 	setAcceptHoverEvents(true);
 }
 
 QString ImagePrivate::name() const {
 	return q->name();
 }
 
 /*!
 	calculates the position and the bounding box of the label. Called on geometry or text changes.
  */
 void ImagePrivate::retransform() {
 	if (suppressRetransform)
 		return;
 
 	if (position.horizontalPosition != WorksheetElement::hPositionCustom
 	        || position.verticalPosition != WorksheetElement::vPositionCustom)
 		updatePosition();
 
 	float x = position.point.x();
 	float y = position.point.y();
 
 	//determine the size of the label in scene units
 	float w, h;
 	if (!image.isNull()) {
 		w = image.width();
 		h = image.height();
 	} else {
 		w = Worksheet::convertToSceneUnits(2, Worksheet::Centimeter);
 		h = Worksheet::convertToSceneUnits(3, Worksheet::Centimeter);
 	}
 
  	//depending on the alignment, calculate the new GraphicsItem's position in parent's coordinate system
 	QPointF itemPos;
 	switch (horizontalAlignment) {
 	case WorksheetElement::hAlignLeft:
 		itemPos.setX(x - w/2);
 		break;
 	case WorksheetElement::hAlignCenter:
 		itemPos.setX(x);
 		break;
 	case WorksheetElement::hAlignRight:
 		itemPos.setX(x + w/2);
 		break;
 	}
 
 	switch (verticalAlignment) {
 	case WorksheetElement::vAlignTop:
 		itemPos.setY(y - h/2);
 		break;
 	case WorksheetElement::vAlignCenter:
 		itemPos.setY(y);
 		break;
 	case WorksheetElement::vAlignBottom:
 		itemPos.setY(y + h/2);
 		break;
 	}
 
 	suppressItemChangeEvent = true;
 	setPos(itemPos);
 	suppressItemChangeEvent = false;
 
 	boundingRectangle.setX(-w/2);
 	boundingRectangle.setY(-h/2);
 	boundingRectangle.setWidth(w);
 	boundingRectangle.setHeight(h);
 
 	updateBorder();
 }
 
 void ImagePrivate::updateImage() {
 	if (!fileName.isEmpty())
 		image = QImage(fileName);
 	else
 		image = QImage();
 
 	retransform();
 }
 
 /*!
 	calculates the position of the label, when the position relative to the parent was specified (left, right, etc.)
 */
 void ImagePrivate::updatePosition() {
 	//determine the parent item
 	QRectF parentRect;
 	QGraphicsItem* parent = parentItem();
 	if (parent) {
 		parentRect = parent->boundingRect();
 	} else {
 		if (!scene())
 			return;
 
 		parentRect = scene()->sceneRect();
 	}
 
 	if (position.horizontalPosition != WorksheetElement::hPositionCustom) {
 		if (position.horizontalPosition == WorksheetElement::hPositionLeft)
 			position.point.setX( parentRect.x() );
 		else if (position.horizontalPosition == WorksheetElement::hPositionCenter)
 			position.point.setX( parentRect.x() + parentRect.width()/2 );
 		else if (position.horizontalPosition == WorksheetElement::hPositionRight)
 			position.point.setX( parentRect.x() + parentRect.width() );
 	}
 
 	if (position.verticalPosition != WorksheetElement::vPositionCustom) {
 		if (position.verticalPosition == WorksheetElement::vPositionTop)
 			position.point.setY( parentRect.y() );
 		else if (position.verticalPosition == WorksheetElement::vPositionCenter)
 			position.point.setY( parentRect.y() + parentRect.height()/2 );
 		else if (position.verticalPosition == WorksheetElement::vPositionBottom)
 			position.point.setY( parentRect.y() + parentRect.height() );
 	}
 
 	emit q->positionChanged(position);
 }
 
 void ImagePrivate::updateBorder() {
 	borderShapePath = QPainterPath();
 	borderShapePath.addRect(boundingRectangle);
 	recalcShapeAndBoundingRect();
 }
 
 bool ImagePrivate::swapVisible(bool on) {
 	bool oldValue = isVisible();
 	setVisible(on);
 	emit q->changed();
 	emit q->visibleChanged(on);
 	return oldValue;
 }
 
 /*!
 	Returns the outer bounds of the item as a rectangle.
  */
 QRectF ImagePrivate::boundingRect() const {
 	return transformedBoundingRectangle;
 }
 
 /*!
 	Returns the shape of this item as a QPainterPath in local coordinates.
 */
 QPainterPath ImagePrivate::shape() const {
 	return imageShape;
 }
 
 /*!
   recalculates the outer bounds and the shape of the label.
 */
 void ImagePrivate::recalcShapeAndBoundingRect() {
 	prepareGeometryChange();
 
 	QMatrix matrix;
 	matrix.rotate(-rotationAngle);
 	imageShape = QPainterPath();
 	if (borderPen.style() != Qt::NoPen) {
 		imageShape.addPath(WorksheetElement::shapeFromPath(borderShapePath, borderPen));
 		transformedBoundingRectangle = matrix.mapRect(imageShape.boundingRect());
 	} else {
 		imageShape.addRect(boundingRectangle);
 		transformedBoundingRectangle = matrix.mapRect(boundingRectangle);
 	}
 
 	imageShape = matrix.map(imageShape);
 
 	emit q->changed();
 }
 
 void ImagePrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	painter->save();
 
 	//draw the text
 	painter->rotate(-rotationAngle);
 	painter->setOpacity(opacity);
 	if (!image.isNull())
 		painter->drawImage(boundingRectangle.topLeft(), image, image.rect());
 	else {
 		painter->setPen(Qt::black);
 		painter->drawPath(borderShapePath);
 		painter->fillRect(image.rect(), QBrush(Qt::Dense6Pattern));
 	}
 	painter->restore();
 
 	//draw the border
 	if (borderPen.style() != Qt::NoPen) {
 		painter->save();
 		painter->rotate(-rotationAngle);
 		painter->setPen(borderPen);
 		painter->setOpacity(borderOpacity);
 		painter->drawPath(borderShapePath);
 		painter->restore();
 	}
 
 	if (m_hovered && !isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Shadow), 2, Qt::SolidLine));
 		painter->drawPath(imageShape);
 	}
 
 	if (isSelected() && !m_printing) {
 		painter->setPen(QPen(QApplication::palette().color(QPalette::Highlight), 2, Qt::SolidLine));
 		painter->drawPath(imageShape);
 	}
 }
 
 QVariant ImagePrivate::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (suppressItemChangeEvent)
 		return value;
 
 	if (change == QGraphicsItem::ItemPositionChange) {
 		//convert item's center point in parent's coordinates
 		WorksheetElement::PositionWrapper tempPosition;
 		tempPosition.point = positionFromItemPosition(value.toPointF());
 		tempPosition.horizontalPosition = WorksheetElement::hPositionCustom;
 		tempPosition.verticalPosition = WorksheetElement::vPositionCustom;
 
 		//emit the signals in order to notify the UI.
 		//we don't set the position related member variables during the mouse movements.
 		//this is done on mouse release events only.
 		emit q->positionChanged(tempPosition);
 	}
 
 	return QGraphicsItem::itemChange(change, value);
 }
 
 void ImagePrivate::mouseReleaseEvent(QGraphicsSceneMouseEvent* event) {
 	//convert position of the item in parent coordinates to label's position
 	QPointF point = positionFromItemPosition(pos());
 	if (qAbs(point.x()-position.point.x())>20 && qAbs(point.y()-position.point.y())>20 ) {
 		//position was changed -> set the position related member variables
 		suppressRetransform = true;
 		WorksheetElement::PositionWrapper tempPosition;
 		tempPosition.point = point;
 		tempPosition.horizontalPosition = WorksheetElement::hPositionCustom;
 		tempPosition.verticalPosition = WorksheetElement::vPositionCustom;
 		q->setPosition(tempPosition);
 		suppressRetransform = false;
 	}
 
 	QGraphicsItem::mouseReleaseEvent(event);
 }
 
 /*!
  *	converts label's position to GraphicsItem's position.
  */
 QPointF ImagePrivate::positionFromItemPosition(QPointF itemPos) {
 	float x = itemPos.x();
 	float y = itemPos.y();
 	float w = image.width();
 	float h = image.height();
 	QPointF tmpPosition;
 
 	//depending on the alignment, calculate the new position
 	switch (horizontalAlignment) {
 	case WorksheetElement::hAlignLeft:
 		tmpPosition.setX(x + w/2);
 		break;
 	case WorksheetElement::hAlignCenter:
 		tmpPosition.setX(x);
 		break;
 	case WorksheetElement::hAlignRight:
 		tmpPosition.setX(x - w/2);
 		break;
 	}
 
 	switch (verticalAlignment) {
 	case WorksheetElement::vAlignTop:
 		tmpPosition.setY(y + h/2);
 		break;
 	case WorksheetElement::vAlignCenter:
 		tmpPosition.setY(y);
 		break;
 	case WorksheetElement::vAlignBottom:
 		tmpPosition.setY(y - h/2);
 		break;
 	}
 
 	return tmpPosition;
 }
 
 void ImagePrivate::contextMenuEvent(QGraphicsSceneContextMenuEvent* event) {
 	q->createContextMenu()->exec(event->screenPos());
 }
 
 void ImagePrivate::hoverEnterEvent(QGraphicsSceneHoverEvent*) {
 	if (!isSelected()) {
 		m_hovered = true;
 		emit q->hovered();
 		update();
 	}
 }
 
 void ImagePrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent*) {
 	if (m_hovered) {
 		m_hovered = false;
 		emit q->unhovered();
 		update();
 	}
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 //! Save as XML
 void Image::save(QXmlStreamWriter* writer) const {
 	Q_D(const Image);
 
 	writer->writeStartElement("image");
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//general
 	writer->writeStartElement("image");
 	writer->writeAttribute("fileName", d->fileName);
 	writer->writeAttribute("opacity", QString::number(d->borderOpacity));
 	writer->writeEndElement();
 
 	//geometry
 	writer->writeStartElement( "geometry" );
 	writer->writeAttribute( "x", QString::number(d->position.point.x()) );
 	writer->writeAttribute( "y", QString::number(d->position.point.y()) );
 	writer->writeAttribute( "horizontalPosition", QString::number(d->position.horizontalPosition) );
 	writer->writeAttribute( "verticalPosition", QString::number(d->position.verticalPosition) );
 	writer->writeAttribute( "horizontalAlignment", QString::number(d->horizontalAlignment) );
 	writer->writeAttribute( "verticalAlignment", QString::number(d->verticalAlignment) );
 	writer->writeAttribute( "rotationAngle", QString::number(d->rotationAngle) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//border
 	writer->writeStartElement("border");
 	WRITE_QPEN(d->borderPen);
 	writer->writeAttribute("borderOpacity", QString::number(d->borderOpacity));
 	writer->writeEndElement();
 
 	writer->writeEndElement(); // close "image" section
 }
 
 //! Load from XML
 bool Image::load(XmlStreamReader* reader, bool preview) {
 	if (!readBasicAttributes(reader))
 		return false;
 
 	Q_D(Image);
 	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() == "image")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (!preview && reader->name() == "comment") {
 			if (!readCommentElement(reader)) return false;
 		} else if (!preview && reader->name() == "geometry") {
 			attribs = reader->attributes();
 
 			str = attribs.value("x").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("x").toString());
 			else
 				d->position.point.setX(str.toDouble());
 
 			str = attribs.value("y").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("y").toString());
 			else
 				d->position.point.setY(str.toDouble());
 
 			READ_INT_VALUE("horizontalPosition", position.horizontalPosition, WorksheetElement::HorizontalPosition);
 			READ_INT_VALUE("verticalPosition", position.verticalPosition, WorksheetElement::VerticalPosition);
 			READ_INT_VALUE("horizontalAlignment", horizontalAlignment, WorksheetElement::HorizontalAlignment);
 			READ_INT_VALUE("verticalAlignment", verticalAlignment, WorksheetElement::VerticalAlignment);
 			READ_DOUBLE_VALUE("rotationAngle", rotationAngle);
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (!preview && reader->name() == "border") {
 			attribs = reader->attributes();
 			READ_QPEN(d->borderPen);
 			READ_DOUBLE_VALUE("borderOpacity", borderOpacity);
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	if (preview)
 		return true;
 
 	retransform();
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void Image::loadThemeConfig(const KConfig& config) {
 	Q_UNUSED(config)
 }
 
 void Image::saveThemeConfig(const KConfig& config) {
 	Q_UNUSED(config)
 }
diff --git a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
index be66dc7a5..f7e6ce2df 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.cpp
@@ -1,3936 +1,3952 @@
 /***************************************************************************
     File                 : CartesianPlot.cpp
     Project              : LabPlot
     Description          : Cartesian plot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2016-2018 by Stefan Gerlach (stefan.gerlach@uni.kn)
     Copyright            : (C) 2017-2018 by Garvit Khatri (garvitdelhi@gmail.com)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "CartesianPlot.h"
 #include "CartesianPlotPrivate.h"
 #include "Axis.h"
 #include "XYCurve.h"
 #include "Histogram.h"
 #include "XYEquationCurve.h"
 #include "XYDataReductionCurve.h"
 #include "XYDifferentiationCurve.h"
 #include "XYIntegrationCurve.h"
 #include "XYInterpolationCurve.h"
 #include "XYSmoothCurve.h"
 #include "XYFitCurve.h"
 #include "XYFourierFilterCurve.h"
 #include "XYFourierTransformCurve.h"
 #include "XYConvolutionCurve.h"
 #include "XYCorrelationCurve.h"
 #include "backend/core/Project.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlotLegend.h"
 #include "backend/worksheet/plots/cartesian/CustomPoint.h"
 #include "backend/worksheet/plots/PlotArea.h"
 #include "backend/worksheet/plots/AbstractPlotPrivate.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
+#include "backend/worksheet/Image.h"
 #include "backend/worksheet/TextLabel.h"
 #include "backend/lib/XmlStreamReader.h"
 #include "backend/lib/commandtemplates.h"
 #include "backend/lib/macros.h"
 #include "backend/lib/trace.h"
 #include "kdefrontend/spreadsheet/PlotDataDialog.h" //for PlotDataDialog::AnalysisAction. TODO: find a better place for this enum.
 #include "kdefrontend/ThemeHandler.h"
 #include "kdefrontend/widgets/ThemesWidget.h"
 
 #include <QDir>
 #include <QDropEvent>
 #include <QIcon>
 #include <QMenu>
 #include <QMimeData>
 #include <QPainter>
 #include <QWidgetAction>
 
 #include <array>
 #include <cmath>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 /**
  * \class CartesianPlot
  * \brief A xy-plot.
  *
  *
  */
 CartesianPlot::CartesianPlot(const QString &name)
 	: AbstractPlot(name, new CartesianPlotPrivate(this), AspectType::CartesianPlot) {
 
 	init();
 }
 
 CartesianPlot::CartesianPlot(const QString &name, CartesianPlotPrivate *dd)
 	: AbstractPlot(name, dd, AspectType::CartesianPlot) {
 
 	init();
 }
 
 CartesianPlot::~CartesianPlot() {
 	if (m_menusInitialized) {
 		delete addNewMenu;
 		delete zoomMenu;
 		delete themeMenu;
 	}
 
 	delete m_coordinateSystem;
 
 	//don't need to delete objects added with addChild()
 
 	//no need to delete the d-pointer here - it inherits from QGraphicsItem
 	//and is deleted during the cleanup in QGraphicsScene
 }
 
 /*!
 	initializes all member variables of \c CartesianPlot
 */
 void CartesianPlot::init() {
 	Q_D(CartesianPlot);
 
 	d->cSystem = new CartesianCoordinateSystem(this);
 	m_coordinateSystem = d->cSystem;
 
 	d->rangeType = CartesianPlot::RangeFree;
 	d->xRangeFormat = CartesianPlot::Numeric;
 	d->yRangeFormat = CartesianPlot::Numeric;
 	d->xRangeDateTimeFormat = "yyyy-MM-dd hh:mm:ss";
 	d->yRangeDateTimeFormat = "yyyy-MM-dd hh:mm:ss";
 	d->rangeFirstValues = 1000;
 	d->rangeLastValues = 1000;
 	d->autoScaleX = true;
 	d->autoScaleY = true;
 	d->xScale = ScaleLinear;
 	d->yScale = ScaleLinear;
 	d->xRangeBreakingEnabled = false;
 	d->yRangeBreakingEnabled = false;
 
 	//the following factor determines the size of the offset between the min/max points of the curves
 	//and the coordinate system ranges, when doing auto scaling
 	//Factor 0 corresponds to the exact match - min/max values of the curves correspond to the start/end values of the ranges.
 	//TODO: make this factor optional.
 	//Provide in the UI the possibility to choose between "exact" or 0% offset, 2%, 5% and 10% for the auto fit option
 	d->autoScaleOffsetFactor = 0.0f;
 
 	m_plotArea = new PlotArea(name() + " plot area", this);
 	addChildFast(m_plotArea);
 
 	//Plot title
 	m_title = new TextLabel(this->name() + QLatin1String("- ") + i18n("Title"), TextLabel::PlotTitle);
 	addChild(m_title);
 	m_title->setHidden(true);
 	m_title->setParentGraphicsItem(m_plotArea->graphicsItem());
 
 	//offset between the plot area and the area defining the coordinate system, in scene units.
 	d->horizontalPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->verticalPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->rightPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->bottomPadding = Worksheet::convertToSceneUnits(1.5, Worksheet::Centimeter);
 	d->symmetricPadding = true;
 
 	connect(this, &AbstractAspect::aspectAdded, this, &CartesianPlot::childAdded);
 	connect(this, &AbstractAspect::aspectRemoved, this, &CartesianPlot::childRemoved);
 
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemClipsChildrenToShape, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsSelectable, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
 	graphicsItem()->setFlag(QGraphicsItem::ItemIsFocusable, true);
 
 	//theme is not set at this point, initialize the color palette with default colors
 	this->setColorPalette(KConfig());
 }
 
 /*!
 	initializes all children of \c CartesianPlot and
 	setups a default plot of type \c type with a plot title.
 */
 void CartesianPlot::initDefault(Type type) {
 	Q_D(CartesianPlot);
 
 	switch (type) {
 	case FourAxes: {
 			d->xMin = 0.0;
 			d->xMax = 1.0;
 			d->yMin = 0.0;
 			d->yMax = 1.0;
 
 			//Axes
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisBottom);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			QPen pen = axis->majorGridPen();
 			pen.setStyle(Qt::SolidLine);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::DotLine);
 			axis->setMinorGridPen(pen);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("x axis 2", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisTop);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMinorGridPen(pen);
 			axis->setLabelsPosition(Axis::NoLabels);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisLeft);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			pen = axis->majorGridPen();
 			pen.setStyle(Qt::SolidLine);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::DotLine);
 			axis->setMinorGridPen(pen);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 2", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisRight);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setOffset(1);
 			axis->setMajorTicksDirection(Axis::ticksIn);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksIn);
 			axis->setMinorTicksNumber(1);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setMajorGridPen(pen);
 			pen = axis->minorGridPen();
 			pen.setStyle(Qt::NoPen);
 			axis->setLabelsPosition(Axis::NoLabels);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxes: {
 			d->xMin = 0.0;
 			d->xMax = 1.0;
 			d->yMin = 0.0;
 			d->yMax = 1.0;
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisBottom);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisLeft);
 			axis->setStart(0);
 			axis->setEnd(1);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxesCentered: {
 			d->xMin = -0.5;
 			d->xMax = 0.5;
 			d->yMin = -0.5;
 			d->yMax = 0.5;
 
 			d->horizontalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 			d->verticalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 
 			QPen pen = m_plotArea->borderPen();
 			pen.setStyle(Qt::NoPen);
 			m_plotArea->setBorderPen(pen);
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCentered);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCentered);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	case TwoAxesCenteredZero: {
 			d->xMin = -0.5;
 			d->xMax = 0.5;
 			d->yMin = -0.5;
 			d->yMax = 0.5;
 
 			d->horizontalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 			d->verticalPadding = Worksheet::convertToSceneUnits(1.0, Worksheet::Centimeter);
 
 			QPen pen = m_plotArea->borderPen();
 			pen.setStyle(Qt::NoPen);
 			m_plotArea->setBorderPen(pen);
 
 			Axis* axis = new Axis("x axis 1", Axis::AxisHorizontal);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCustom);
 			axis->setOffset(0);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			axis = new Axis("y axis 1", Axis::AxisVertical);
 			axis->setSuppressRetransform(true);
 			addChild(axis);
 			axis->setPosition(Axis::AxisCustom);
 			axis->setOffset(0);
 			axis->setStart(-0.5);
 			axis->setEnd(0.5);
 			axis->setMajorTicksDirection(Axis::ticksBoth);
 			axis->setMajorTicksNumber(6);
 			axis->setMinorTicksDirection(Axis::ticksBoth);
 			axis->setMinorTicksNumber(1);
 			axis->setArrowType(Axis::FilledArrowSmall);
 			axis->title()->setText(QString());
 			axis->setSuppressRetransform(false);
 
 			break;
 		}
 	}
 
 	d->xMinPrev = d->xMin;
 	d->xMaxPrev = d->xMax;
 	d->yMinPrev = d->yMin;
 	d->yMaxPrev = d->yMax;
 
 	//Geometry, specify the plot rect in scene coordinates.
 	//TODO: Use default settings for left, top, width, height and for min/max for the coordinate system
 	float x = Worksheet::convertToSceneUnits(2, Worksheet::Centimeter);
 	float y = Worksheet::convertToSceneUnits(2, Worksheet::Centimeter);
 	float w = Worksheet::convertToSceneUnits(10, Worksheet::Centimeter);
 	float h = Worksheet::convertToSceneUnits(10, Worksheet::Centimeter);
 
 	//all plot children are initialized -> set the geometry of the plot in scene coordinates.
 	d->rect = QRectF(x,y,w,h);
 	d->retransform();
 }
 
 void CartesianPlot::initActions() {
 	//"add new" actions
 	addCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("xy-curve"), this);
 	addHistogramAction = new QAction(QIcon::fromTheme("view-object-histogram-linear"), i18n("Histogram"), this);
 	addEquationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-equation-curve"), i18n("xy-curve from a mathematical Equation"), this);
 // no icons yet
 	addDataReductionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Reduction"), this);
 	addDifferentiationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Differentiation"), this);
 	addIntegrationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Integration"), this);
 	addInterpolationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("Interpolation"), this);
 	addSmoothCurveAction = new QAction(QIcon::fromTheme("labplot-xy-smoothing-curve"), i18n("Smooth"), this);
 	addFitCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Fit"), this);
 	addFourierFilterCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-filter-curve"), i18n("Fourier Filter"), this);
 	addFourierTransformCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-transform-curve"), i18n("Fourier Transform"), this);
 	addConvolutionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"),i18n("(De-)Convolution"), this);
 	addCorrelationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"),i18n("Auto-/Cross-Correlation"), this);
 
 	addLegendAction = new QAction(QIcon::fromTheme("text-field"), i18n("Legend"), this);
 	if (children<CartesianPlotLegend>().size()>0)
 		addLegendAction->setEnabled(false);	//only one legend is allowed -> disable the action
 
 	addHorizontalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-horizontal"), i18n("Horizontal Axis"), this);
 	addVerticalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-vertical"), i18n("Vertical Axis"), this);
 	addTextLabelAction = new QAction(QIcon::fromTheme("draw-text"), i18n("Text Label"), this);
+	addImageAction = new QAction(QIcon::fromTheme("viewimage"), i18n("Image"), this);
 	addCustomPointAction = new QAction(QIcon::fromTheme("draw-cross"), i18n("Custom Point"), this);
 
 	connect(addCurveAction, &QAction::triggered, this, &CartesianPlot::addCurve);
 	connect(addHistogramAction,&QAction::triggered, this, &CartesianPlot::addHistogram);
 	connect(addEquationCurveAction, &QAction::triggered, this, &CartesianPlot::addEquationCurve);
 	connect(addDataReductionCurveAction, &QAction::triggered, this, &CartesianPlot::addDataReductionCurve);
 	connect(addDifferentiationCurveAction, &QAction::triggered, this, &CartesianPlot::addDifferentiationCurve);
 	connect(addIntegrationCurveAction, &QAction::triggered, this, &CartesianPlot::addIntegrationCurve);
 	connect(addInterpolationCurveAction, &QAction::triggered, this, &CartesianPlot::addInterpolationCurve);
 	connect(addSmoothCurveAction, &QAction::triggered, this, &CartesianPlot::addSmoothCurve);
 	connect(addFitCurveAction, &QAction::triggered, this, &CartesianPlot::addFitCurve);
 	connect(addFourierFilterCurveAction, &QAction::triggered, this, &CartesianPlot::addFourierFilterCurve);
 	connect(addFourierTransformCurveAction, &QAction::triggered, this, &CartesianPlot::addFourierTransformCurve);
 	connect(addConvolutionCurveAction, &QAction::triggered, this, &CartesianPlot::addConvolutionCurve);
 	connect(addCorrelationCurveAction, &QAction::triggered, this, &CartesianPlot::addCorrelationCurve);
 
 	connect(addLegendAction, &QAction::triggered, this, static_cast<void (CartesianPlot::*)()>(&CartesianPlot::addLegend));
 	connect(addHorizontalAxisAction, &QAction::triggered, this, &CartesianPlot::addHorizontalAxis);
 	connect(addVerticalAxisAction, &QAction::triggered, this, &CartesianPlot::addVerticalAxis);
 	connect(addTextLabelAction, &QAction::triggered, this, &CartesianPlot::addTextLabel);
+	connect(addImageAction, &QAction::triggered, this, &CartesianPlot::addImage);
 	connect(addCustomPointAction, &QAction::triggered, this, &CartesianPlot::addCustomPoint);
 
 	//Analysis menu actions
 // 	addDataOperationAction = new QAction(i18n("Data Operation"), this);
 	addDataReductionAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Reduction"), this);
 	addDifferentiationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Differentiate"), this);
 	addIntegrationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Integrate"), this);
 	addInterpolationAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("Interpolate"), this);
 	addSmoothAction = new QAction(QIcon::fromTheme("labplot-xy-smoothing-curve"), i18n("Smooth"), this);
 	addConvolutionAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Convolute/Deconvolute"), this);
 	addCorrelationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Auto-/Cross-Correlation"), this);
 
 	QAction* fitAction = new QAction(i18n("Linear"), this);
 	fitAction->setData(PlotDataDialog::FitLinear);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Power"), this);
 	fitAction->setData(PlotDataDialog::FitPower);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Exponential (degree 1)"), this);
 	fitAction->setData(PlotDataDialog::FitExp1);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Exponential (degree 2)"), this);
 	fitAction->setData(PlotDataDialog::FitExp2);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Inverse exponential"), this);
 	fitAction->setData(PlotDataDialog::FitInvExp);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Gauss"), this);
 	fitAction->setData(PlotDataDialog::FitGauss);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Cauchy-Lorentz"), this);
 	fitAction->setData(PlotDataDialog::FitCauchyLorentz);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Arc Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTan);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Hyperbolic Tangent"), this);
 	fitAction->setData(PlotDataDialog::FitTanh);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Error Function"), this);
 	fitAction->setData(PlotDataDialog::FitErrFunc);
 	addFitAction.append(fitAction);
 
 	fitAction = new QAction(i18n("Custom"), this);
 	fitAction->setData(PlotDataDialog::FitCustom);
 	addFitAction.append(fitAction);
 
 	addFourierFilterAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-filter-curve"), i18n("Fourier Filter"), this);
 	addFourierTransformAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-transform-curve"), i18n("Fourier Transform"), this);
 
 	connect(addDataReductionAction, &QAction::triggered, this, &CartesianPlot::addDataReductionCurve);
 	connect(addDifferentiationAction, &QAction::triggered, this, &CartesianPlot::addDifferentiationCurve);
 	connect(addIntegrationAction, &QAction::triggered, this, &CartesianPlot::addIntegrationCurve);
 	connect(addInterpolationAction, &QAction::triggered, this, &CartesianPlot::addInterpolationCurve);
 	connect(addSmoothAction, &QAction::triggered, this, &CartesianPlot::addSmoothCurve);
 	connect(addConvolutionAction, &QAction::triggered, this, &CartesianPlot::addConvolutionCurve);
 	connect(addCorrelationAction, &QAction::triggered, this, &CartesianPlot::addCorrelationCurve);
 	for (const auto& action : addFitAction)
 		connect(action, &QAction::triggered, this, &CartesianPlot::addFitCurve);
 	connect(addFourierFilterAction, &QAction::triggered, this, &CartesianPlot::addFourierFilterCurve);
 	connect(addFourierTransformAction, &QAction::triggered, this, &CartesianPlot::addFourierTransformCurve);
 
 	//zoom/navigate actions
 	scaleAutoAction = new QAction(QIcon::fromTheme("labplot-auto-scale-all"), i18n("Auto Scale"), this);
 	scaleAutoXAction = new QAction(QIcon::fromTheme("labplot-auto-scale-x"), i18n("Auto Scale X"), this);
 	scaleAutoYAction = new QAction(QIcon::fromTheme("labplot-auto-scale-y"), i18n("Auto Scale Y"), this);
 	zoomInAction = new QAction(QIcon::fromTheme("zoom-in"), i18n("Zoom In"), this);
 	zoomOutAction = new QAction(QIcon::fromTheme("zoom-out"), i18n("Zoom Out"), this);
 	zoomInXAction = new QAction(QIcon::fromTheme("labplot-zoom-in-x"), i18n("Zoom In X"), this);
 	zoomOutXAction = new QAction(QIcon::fromTheme("labplot-zoom-out-x"), i18n("Zoom Out X"), this);
 	zoomInYAction = new QAction(QIcon::fromTheme("labplot-zoom-in-y"), i18n("Zoom In Y"), this);
 	zoomOutYAction = new QAction(QIcon::fromTheme("labplot-zoom-out-y"), i18n("Zoom Out Y"), this);
 	shiftLeftXAction = new QAction(QIcon::fromTheme("labplot-shift-left-x"), i18n("Shift Left X"), this);
 	shiftRightXAction = new QAction(QIcon::fromTheme("labplot-shift-right-x"), i18n("Shift Right X"), this);
 	shiftUpYAction = new QAction(QIcon::fromTheme("labplot-shift-up-y"), i18n("Shift Up Y"), this);
 	shiftDownYAction = new QAction(QIcon::fromTheme("labplot-shift-down-y"), i18n("Shift Down Y"), this);
 
 	connect(scaleAutoAction, &QAction::triggered, this, &CartesianPlot::scaleAutoTriggered);
 	connect(scaleAutoXAction, &QAction::triggered, this, &CartesianPlot::scaleAutoTriggered);
 	connect(scaleAutoYAction, &QAction::triggered, this, &CartesianPlot::scaleAutoTriggered);
 	connect(zoomInAction, &QAction::triggered, this, &CartesianPlot::zoomIn);
 	connect(zoomOutAction, &QAction::triggered, this, &CartesianPlot::zoomOut);
 	connect(zoomInXAction, &QAction::triggered, this, &CartesianPlot::zoomInX);
 	connect(zoomOutXAction, &QAction::triggered, this, &CartesianPlot::zoomOutX);
 	connect(zoomInYAction, &QAction::triggered, this, &CartesianPlot::zoomInY);
 	connect(zoomOutYAction, &QAction::triggered, this, &CartesianPlot::zoomOutY);
 	connect(shiftLeftXAction, &QAction::triggered, this, &CartesianPlot::shiftLeftX);
 	connect(shiftRightXAction, &QAction::triggered, this, &CartesianPlot::shiftRightX);
 	connect(shiftUpYAction, &QAction::triggered, this, &CartesianPlot::shiftUpY);
 	connect(shiftDownYAction, &QAction::triggered, this, &CartesianPlot::shiftDownY);
 
 	//visibility action
 	visibilityAction = new QAction(QIcon::fromTheme("view-visible"), i18n("Visible"), this);
 	visibilityAction->setCheckable(true);
 	connect(visibilityAction, &QAction::triggered, this, &CartesianPlot::visibilityChanged);
 }
 
 void CartesianPlot::initMenus() {
 	initActions();
 
 	addNewMenu = new QMenu(i18n("Add New"));
 	addNewMenu->setIcon(QIcon::fromTheme("list-add"));
 	addNewMenu->addAction(addCurveAction);
 	addNewMenu->addAction(addHistogramAction);
 	addNewMenu->addAction(addEquationCurveAction);
 	addNewMenu->addSeparator();
 
 	addNewAnalysisMenu = new QMenu(i18n("Analysis Curve"));
 	addNewAnalysisMenu->addAction(addFitCurveAction);
 	addNewAnalysisMenu->addSeparator();
 	addNewAnalysisMenu->addAction(addDifferentiationCurveAction);
 	addNewAnalysisMenu->addAction(addIntegrationCurveAction);
 	addNewAnalysisMenu->addSeparator();
 	addNewAnalysisMenu->addAction(addInterpolationCurveAction);
 	addNewAnalysisMenu->addAction(addSmoothCurveAction);
 	addNewAnalysisMenu->addSeparator();
 	addNewAnalysisMenu->addAction(addFourierFilterCurveAction);
 	addNewAnalysisMenu->addAction(addFourierTransformCurveAction);
 	addNewAnalysisMenu->addSeparator();
 	addNewAnalysisMenu->addAction(addConvolutionCurveAction);
 	addNewAnalysisMenu->addAction(addCorrelationCurveAction);
 	addNewAnalysisMenu->addSeparator();
 	addNewAnalysisMenu->addAction(addDataReductionCurveAction);
 	addNewMenu->addMenu(addNewAnalysisMenu);
 
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addLegendAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addHorizontalAxisAction);
 	addNewMenu->addAction(addVerticalAxisAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addTextLabelAction);
+	addNewMenu->addAction(addImageAction);
 	addNewMenu->addSeparator();
 	addNewMenu->addAction(addCustomPointAction);
 
 	zoomMenu = new QMenu(i18n("Zoom/Navigate"));
 	zoomMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	zoomMenu->addAction(scaleAutoAction);
 	zoomMenu->addAction(scaleAutoXAction);
 	zoomMenu->addAction(scaleAutoYAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInAction);
 	zoomMenu->addAction(zoomOutAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInXAction);
 	zoomMenu->addAction(zoomOutXAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(zoomInYAction);
 	zoomMenu->addAction(zoomOutYAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(shiftLeftXAction);
 	zoomMenu->addAction(shiftRightXAction);
 	zoomMenu->addSeparator();
 	zoomMenu->addAction(shiftUpYAction);
 	zoomMenu->addAction(shiftDownYAction);
 
 	// Data manipulation menu
 // 	QMenu* dataManipulationMenu = new QMenu(i18n("Data Manipulation"));
 // 	dataManipulationMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 // 	dataManipulationMenu->addAction(addDataOperationAction);
 // 	dataManipulationMenu->addAction(addDataReductionAction);
 
 	// Data fit menu
 	QMenu* dataFitMenu = new QMenu(i18n("Fit"));
 	dataFitMenu->setIcon(QIcon::fromTheme("labplot-xy-fit-curve"));
 	dataFitMenu->addAction(addFitAction.at(0));
 	dataFitMenu->addAction(addFitAction.at(1));
 	dataFitMenu->addAction(addFitAction.at(2));
 	dataFitMenu->addAction(addFitAction.at(3));
 	dataFitMenu->addAction(addFitAction.at(4));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(5));
 	dataFitMenu->addAction(addFitAction.at(6));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(7));
 	dataFitMenu->addAction(addFitAction.at(8));
 	dataFitMenu->addAction(addFitAction.at(9));
 	dataFitMenu->addSeparator();
 	dataFitMenu->addAction(addFitAction.at(10));
 
 	//analysis menu
 	dataAnalysisMenu = new QMenu(i18n("Analysis"));
 	dataAnalysisMenu->addMenu(dataFitMenu);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addDifferentiationAction);
 	dataAnalysisMenu->addAction(addIntegrationAction);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addInterpolationAction);
 	dataAnalysisMenu->addAction(addSmoothAction);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addFourierFilterAction);
 	dataAnalysisMenu->addAction(addFourierTransformAction);
 	dataAnalysisMenu->addSeparator();
 	dataAnalysisMenu->addAction(addConvolutionAction);
 	dataAnalysisMenu->addAction(addCorrelationAction);
 	dataAnalysisMenu->addSeparator();
 // 	dataAnalysisMenu->insertMenu(nullptr, dataManipulationMenu);
 	dataAnalysisMenu->addAction(addDataReductionAction);
 
 	//themes menu
 	themeMenu = new QMenu(i18n("Apply Theme"));
 	themeMenu->setIcon(QIcon::fromTheme("color-management"));
 	auto* themeWidget = new ThemesWidget(nullptr);
 	connect(themeWidget, &ThemesWidget::themeSelected, this, &CartesianPlot::loadTheme);
 	connect(themeWidget, &ThemesWidget::themeSelected, themeMenu, &QMenu::close);
 
 	auto* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(themeWidget);
 	themeMenu->addAction(widgetAction);
 
 	m_menusInitialized = true;
 }
 
 QMenu* CartesianPlot::createContextMenu() {
 	if (!m_menusInitialized)
 		initMenus();
 
 	QMenu* menu = WorksheetElement::createContextMenu();
 	QAction* firstAction = menu->actions().at(1);
 
 
 	menu->insertMenu(firstAction, addNewMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, zoomMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, themeMenu);
 	menu->insertSeparator(firstAction);
 
 	visibilityAction->setChecked(isVisible());
 	menu->insertAction(firstAction, visibilityAction);
 
 	return menu;
 }
 
 QMenu* CartesianPlot::analysisMenu() {
 	if (!m_menusInitialized)
 		initMenus();
 
 	return dataAnalysisMenu;
 }
 
 /*!
 	Returns an icon to be used in the project explorer.
 */
 QIcon CartesianPlot::icon() const {
 	return QIcon::fromTheme("office-chart-line");
 }
 
 QVector<AbstractAspect*> CartesianPlot::dependsOn() const {
 	//aspects which the plotted data in the worksheet depends on (spreadsheets and later matrices)
 	QVector<AbstractAspect*> aspects;
 
 	for (const auto* curve : children<XYCurve>()) {
 		if (curve->xColumn() && dynamic_cast<Spreadsheet*>(curve->xColumn()->parentAspect()) )
 			aspects << curve->xColumn()->parentAspect();
 
 		if (curve->yColumn() && dynamic_cast<Spreadsheet*>(curve->yColumn()->parentAspect()) )
 			aspects << curve->yColumn()->parentAspect();
 	}
 
 	return aspects;
 }
 
 void CartesianPlot::navigate(CartesianPlot::NavigationOperation op) {
 	Q_D(CartesianPlot);
 	if (op == ScaleAuto) {
 		if (d->curvesXMinMaxIsDirty || d->curvesYMinMaxIsDirty || !autoScaleX() || !autoScaleY()) {
 			d->curvesXMinMaxIsDirty = true;
 			d->curvesYMinMaxIsDirty = true;
 		}
 		scaleAuto();
 	} else if (op == ScaleAutoX) setAutoScaleX(true);
 	else if (op == ScaleAutoY) setAutoScaleY(true);
 	else if (op == ZoomIn) zoomIn();
 	else if (op == ZoomOut) zoomOut();
 	else if (op == ZoomInX) zoomInX();
 	else if (op == ZoomOutX) zoomOutX();
 	else if (op == ZoomInY) zoomInY();
 	else if (op == ZoomOutY) zoomOutY();
 	else if (op == ShiftLeftX) shiftLeftX();
 	else if (op == ShiftRightX) shiftRightX();
 	else if (op == ShiftUpY) shiftUpY();
 	else if (op == ShiftDownY) shiftDownY();
 }
 
 void CartesianPlot::setSuppressDataChangedSignal(bool value) {
 	Q_D(CartesianPlot);
 	d->suppressRetransform = value;
 }
 
 void CartesianPlot::processDropEvent(QDropEvent* event) {
 	PERFTRACE("CartesianPlot::processDropEvent");
 	const QMimeData* mimeData = event->mimeData();
 	if (!mimeData)
 		return;
 
 	//deserialize the mime data to the vector of aspect pointers
 	QByteArray data = mimeData->data(QLatin1String("labplot-dnd"));
 	QVector<quintptr> vec;
 	QDataStream stream(&data, QIODevice::ReadOnly);
 	stream >> vec;
 	QVector<AbstractColumn*> columns;
 	for (auto a : vec) {
 		auto* aspect = (AbstractAspect*)a;
 		auto* column = dynamic_cast<AbstractColumn*>(aspect);
 		if (column)
 			columns << column;
 	}
 
 	//return if there are no columns being dropped.
 	//TODO: extend this later when we allow to drag&drop plots, etc.
 	if (columns.isEmpty())
 		return;
 
 	//determine the first column with "x plot designation" as the x-data column for all curves to be created
 	const AbstractColumn* xColumn = nullptr;
 	for (const auto* column : columns) {
 		if (column->plotDesignation() == AbstractColumn::X) {
 			xColumn = column;
 			break;
 		}
 	}
 
 	//if no column with "x plot designation" is available, use the x-data column of the first curve in the plot,
 	if (xColumn == nullptr) {
 		QVector<XYCurve*> curves = children<XYCurve>();
 		if (!curves.isEmpty())
 			xColumn = curves.at(0)->xColumn();
 	}
 
 	//use the first dropped column if no column with "x plot designation" nor curves are available
 	if (xColumn == nullptr)
 		xColumn = columns.at(0);
 
 	//create curves
 	bool curvesAdded = false;
 	for (const auto* column : columns) {
 		if (column == xColumn)
 			continue;
 
 		XYCurve* curve = new XYCurve(column->name());
 		curve->suppressRetransform(true); //suppress retransform, all curved will be recalculated at the end
 		curve->setXColumn(xColumn);
 		curve->setYColumn(column);
 		addChild(curve);
 		curve->suppressRetransform(false);
 		curvesAdded = true;
 	}
 
 	if (curvesAdded)
 		dataChanged();
 }
 
 bool CartesianPlot::isPanningActive() const {
 	Q_D(const CartesianPlot);
 	return d->panningStarted;
 }
 
 bool CartesianPlot::isHovered() const {
 	Q_D(const CartesianPlot);
 	return d->m_hovered;
 }
 bool CartesianPlot::isPrinted() const {
 	Q_D(const CartesianPlot);
 	return d->m_printing;
 }
 
 bool CartesianPlot::isSelected() const {
 	Q_D(const CartesianPlot);
 	return d->isSelected();
 }
 
 //##############################################################################
 //################################  getter methods  ############################
 //##############################################################################
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeType, rangeType, rangeType)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeFormat, xRangeFormat, xRangeFormat)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeFormat, yRangeFormat, yRangeFormat)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, int, rangeLastValues, rangeLastValues)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, int, rangeFirstValues, rangeFirstValues)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, autoScaleX, autoScaleX)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, xMin, xMin)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, xMax, xMax)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::Scale, xScale, xScale)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, xRangeBreakingEnabled, xRangeBreakingEnabled)
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeBreaks, xRangeBreaks, xRangeBreaks)
 
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, autoScaleY, autoScaleY)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, yMin, yMin)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, double, yMax, yMax)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::Scale, yScale, yScale)
 BASIC_SHARED_D_READER_IMPL(CartesianPlot, bool, yRangeBreakingEnabled, yRangeBreakingEnabled)
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, CartesianPlot::RangeBreaks, yRangeBreaks, yRangeBreaks)
 
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, QPen, cursorPen, cursorPen);
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, bool, cursor0Enable, cursor0Enable);
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, bool, cursor1Enable, cursor1Enable);
 CLASS_SHARED_D_READER_IMPL(CartesianPlot, QString, theme, theme)
 
 /*!
 	returns the actual bounding rectangular of the plot area showing data (plot's rectangular minus padding)
 	in plot's coordinates
  */
 QRectF CartesianPlot::dataRect() const {
 	Q_D(const CartesianPlot);
 	return d->dataRect;
 }
 
 CartesianPlot::MouseMode CartesianPlot::mouseMode() const {
 	Q_D(const CartesianPlot);
 	return d->mouseMode;
 }
 
 const QString& CartesianPlot::xRangeDateTimeFormat() const {
 	Q_D(const CartesianPlot);
 	return d->xRangeDateTimeFormat;
 }
 
 const QString& CartesianPlot::yRangeDateTimeFormat() const {
 	Q_D(const CartesianPlot);
 	return d->yRangeDateTimeFormat;
 }
 
 //##############################################################################
 //######################  setter methods and undo commands  ####################
 //##############################################################################
 /*!
 	set the rectangular, defined in scene coordinates
  */
 class CartesianPlotSetRectCmd : public QUndoCommand {
 public:
 	CartesianPlotSetRectCmd(CartesianPlotPrivate* private_obj, QRectF rect) : m_private(private_obj), m_rect(rect) {
 		setText(i18n("%1: change geometry rect", m_private->name()));
 	};
 
 	void redo() override {
 // 		const double horizontalRatio = m_rect.width() / m_private->rect.width();
 // 		const double verticalRatio = m_rect.height() / m_private->rect.height();
 
 		qSwap(m_private->rect, m_rect);
 
 // 		m_private->q->handleResize(horizontalRatio, verticalRatio, false);
 		m_private->retransform();
 		emit m_private->q->rectChanged(m_private->rect);
 	};
 
 	void undo() override {
 		redo();
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	QRectF m_rect;
 };
 
 void CartesianPlot::setRect(const QRectF& rect) {
 	Q_D(CartesianPlot);
 	if (rect != d->rect)
 		exec(new CartesianPlotSetRectCmd(d, rect));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeType, CartesianPlot::RangeType, rangeType, rangeChanged);
 void CartesianPlot::setRangeType(RangeType type) {
 	Q_D(CartesianPlot);
 	if (type != d->rangeType)
 		exec(new CartesianPlotSetRangeTypeCmd(d, type, ki18n("%1: set range type")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeFormat, CartesianPlot::RangeFormat, xRangeFormat, xRangeFormatChanged);
 void CartesianPlot::setXRangeFormat(RangeFormat format) {
 	Q_D(CartesianPlot);
 	if (format != d->xRangeFormat)
 		exec(new CartesianPlotSetXRangeFormatCmd(d, format, ki18n("%1: set x-range format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeFormat, CartesianPlot::RangeFormat, yRangeFormat, yRangeFormatChanged);
 void CartesianPlot::setYRangeFormat(RangeFormat format) {
 	Q_D(CartesianPlot);
 	if (format != d->yRangeFormat)
 		exec(new CartesianPlotSetYRangeFormatCmd(d, format, ki18n("%1: set y-range format")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeLastValues, int, rangeLastValues, rangeChanged);
 void CartesianPlot::setRangeLastValues(int values) {
 	Q_D(CartesianPlot);
 	if (values != d->rangeLastValues)
 		exec(new CartesianPlotSetRangeLastValuesCmd(d, values, ki18n("%1: set range")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetRangeFirstValues, int, rangeFirstValues, rangeChanged);
 void CartesianPlot::setRangeFirstValues(int values) {
 	Q_D(CartesianPlot);
 	if (values != d->rangeFirstValues)
 		exec(new CartesianPlotSetRangeFirstValuesCmd(d, values, ki18n("%1: set range")));
 }
 
 
 class CartesianPlotSetAutoScaleXCmd : public QUndoCommand {
 public:
 	CartesianPlotSetAutoScaleXCmd(CartesianPlotPrivate* private_obj, bool autoScale) :
 		m_private(private_obj), m_autoScale(autoScale), m_autoScaleOld(false), m_minOld(0.0), m_maxOld(0.0) {
 		setText(i18n("%1: change x-range auto scaling", m_private->name()));
 	};
 
 	void redo() override {
 		m_autoScaleOld = m_private->autoScaleX;
 		if (m_autoScale) {
 			m_minOld = m_private->xMin;
 			m_maxOld = m_private->xMax;
 			m_private->q->scaleAutoX();
 		}
 		m_private->autoScaleX = m_autoScale;
 		emit m_private->q->xAutoScaleChanged(m_autoScale);
 	};
 
 	void undo() override {
 		if (!m_autoScaleOld) {
 			m_private->xMin = m_minOld;
 			m_private->xMax = m_maxOld;
 			m_private->retransformScales();
 		}
 		m_private->autoScaleX = m_autoScaleOld;
 		emit m_private->q->xAutoScaleChanged(m_autoScaleOld);
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	bool m_autoScale;
 	bool m_autoScaleOld;
 	double m_minOld;
 	double m_maxOld;
 };
 
 void CartesianPlot::setAutoScaleX(bool autoScaleX) {
 	Q_D(CartesianPlot);
 	if (autoScaleX != d->autoScaleX)
 		exec(new CartesianPlotSetAutoScaleXCmd(d, autoScaleX));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXMin, double, xMin, retransformScales)
 void CartesianPlot::setXMin(double xMin) {
 	Q_D(CartesianPlot);
 	if (xMin != d->xMin && xMin != -INFINITY && xMin != INFINITY) {
 		d->curvesYMinMaxIsDirty = true;
 		exec(new CartesianPlotSetXMinCmd(d, xMin, ki18n("%1: set min x")));
 		if (d->autoScaleY)
 			scaleAutoY();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXMax, double, xMax, retransformScales)
 void CartesianPlot::setXMax(double xMax) {
 	Q_D(CartesianPlot);
 	if (xMax != d->xMax && xMax != -INFINITY && xMax != INFINITY) {
 		d->curvesYMinMaxIsDirty = true;
 		exec(new CartesianPlotSetXMaxCmd(d, xMax, ki18n("%1: set max x")));
 		if (d->autoScaleY)
 			scaleAutoY();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXScale, CartesianPlot::Scale, xScale, retransformScales)
 void CartesianPlot::setXScale(Scale scale) {
 	Q_D(CartesianPlot);
 	if (scale != d->xScale)
 		exec(new CartesianPlotSetXScaleCmd(d, scale, ki18n("%1: set x scale")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeBreakingEnabled, bool, xRangeBreakingEnabled, retransformScales)
 void CartesianPlot::setXRangeBreakingEnabled(bool enabled) {
 	Q_D(CartesianPlot);
 	if (enabled != d->xRangeBreakingEnabled)
 		exec(new CartesianPlotSetXRangeBreakingEnabledCmd(d, enabled, ki18n("%1: x-range breaking enabled")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetXRangeBreaks, CartesianPlot::RangeBreaks, xRangeBreaks, retransformScales)
 void CartesianPlot::setXRangeBreaks(const RangeBreaks& breakings) {
 	Q_D(CartesianPlot);
 	exec(new CartesianPlotSetXRangeBreaksCmd(d, breakings, ki18n("%1: x-range breaks changed")));
 }
 
 class CartesianPlotSetAutoScaleYCmd : public QUndoCommand {
 public:
 	CartesianPlotSetAutoScaleYCmd(CartesianPlotPrivate* private_obj, bool autoScale) :
 		m_private(private_obj), m_autoScale(autoScale), m_autoScaleOld(false), m_minOld(0.0), m_maxOld(0.0) {
 		setText(i18n("%1: change y-range auto scaling", m_private->name()));
 	};
 
 	void redo() override {
 		m_autoScaleOld = m_private->autoScaleY;
 		if (m_autoScale) {
 			m_minOld = m_private->yMin;
 			m_maxOld = m_private->yMax;
 			m_private->q->scaleAutoY();
 		}
 		m_private->autoScaleY = m_autoScale;
 		emit m_private->q->yAutoScaleChanged(m_autoScale);
 	};
 
 	void undo() override {
 		if (!m_autoScaleOld) {
 			m_private->yMin = m_minOld;
 			m_private->yMax = m_maxOld;
 			m_private->retransformScales();
 		}
 		m_private->autoScaleY = m_autoScaleOld;
 		emit m_private->q->yAutoScaleChanged(m_autoScaleOld);
 	}
 
 private:
 	CartesianPlotPrivate* m_private;
 	bool m_autoScale;
 	bool m_autoScaleOld;
 	double m_minOld;
 	double m_maxOld;
 };
 
 void CartesianPlot::setAutoScaleY(bool autoScaleY) {
 	Q_D(CartesianPlot);
 	if (autoScaleY != d->autoScaleY)
 		exec(new CartesianPlotSetAutoScaleYCmd(d, autoScaleY));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYMin, double, yMin, retransformScales)
 void CartesianPlot::setYMin(double yMin) {
 	Q_D(CartesianPlot);
 	if (yMin != d->yMin) {
 		d->curvesXMinMaxIsDirty = true;
 		exec(new CartesianPlotSetYMinCmd(d, yMin, ki18n("%1: set min y")));
 		if (d->autoScaleX)
 			scaleAutoX();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYMax, double, yMax, retransformScales)
 void CartesianPlot::setYMax(double yMax) {
 	Q_D(CartesianPlot);
 	if (yMax != d->yMax) {
 		d->curvesXMinMaxIsDirty = true;
 		exec(new CartesianPlotSetYMaxCmd(d, yMax, ki18n("%1: set max y")));
 		if (d->autoScaleX)
 			scaleAutoX();
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYScale, CartesianPlot::Scale, yScale, retransformScales)
 void CartesianPlot::setYScale(Scale scale) {
 	Q_D(CartesianPlot);
 	if (scale != d->yScale)
 		exec(new CartesianPlotSetYScaleCmd(d, scale, ki18n("%1: set y scale")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeBreakingEnabled, bool, yRangeBreakingEnabled, retransformScales)
 void CartesianPlot::setYRangeBreakingEnabled(bool enabled) {
 	Q_D(CartesianPlot);
 	if (enabled != d->yRangeBreakingEnabled)
 		exec(new CartesianPlotSetYRangeBreakingEnabledCmd(d, enabled, ki18n("%1: y-range breaking enabled")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetYRangeBreaks, CartesianPlot::RangeBreaks, yRangeBreaks, retransformScales)
 void CartesianPlot::setYRangeBreaks(const RangeBreaks& breaks) {
 	Q_D(CartesianPlot);
 	exec(new CartesianPlotSetYRangeBreaksCmd(d, breaks, ki18n("%1: y-range breaks changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetCursorPen, QPen, cursorPen, update)
 void CartesianPlot::setCursorPen(const QPen &pen) {
 	Q_D(CartesianPlot);
 	if (pen != d->cursorPen)
 		exec(new CartesianPlotSetCursorPenCmd(d, pen, ki18n("%1: y-range breaks changed")));
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetCursor0Enable, bool, cursor0Enable, updateCursor)
 void CartesianPlot::setCursor0Enable(const bool &enable) {
 	Q_D(CartesianPlot);
 	if (enable != d->cursor0Enable) {
 		if (std::isnan(d->cursor0Pos.x())) { // if never set, set initial position
 			d->cursor0Pos.setX(d->cSystem->mapSceneToLogical(QPointF(0,0)).x());
 			mousePressCursorModeSignal(0, d->cursor0Pos); // simulate mousePress to update values in the cursor dock
 		}
 		exec(new CartesianPlotSetCursor0EnableCmd(d, enable, ki18n("%1: Cursor0 enable")));
 	}
 }
 
 STD_SETTER_CMD_IMPL_F_S(CartesianPlot, SetCursor1Enable, bool, cursor1Enable, updateCursor)
 void CartesianPlot::setCursor1Enable(const bool &enable) {
 	Q_D(CartesianPlot);
 	if (enable != d->cursor1Enable) {
 		if (std::isnan(d->cursor1Pos.x())) { // if never set, set initial position
 			d->cursor1Pos.setX(d->cSystem->mapSceneToLogical(QPointF(0,0)).x());
 			mousePressCursorModeSignal(1, d->cursor1Pos); // simulate mousePress to update values in the cursor dock
 		}
 		exec(new CartesianPlotSetCursor1EnableCmd(d, enable, ki18n("%1: Cursor1 enable")));
 	}
 }
 
 STD_SETTER_CMD_IMPL_S(CartesianPlot, SetTheme, QString, theme)
 void CartesianPlot::setTheme(const QString& theme) {
 	Q_D(CartesianPlot);
 	if (theme != d->theme) {
 		if (!theme.isEmpty()) {
 			beginMacro( i18n("%1: load theme %2", name(), theme) );
 			exec(new CartesianPlotSetThemeCmd(d, theme, ki18n("%1: set theme")));
 			loadTheme(theme);
 			endMacro();
 		} else
 			exec(new CartesianPlotSetThemeCmd(d, theme, ki18n("%1: disable theming")));
 	}
 }
 
 //################################################################
 //########################## Slots ###############################
 //################################################################
 void CartesianPlot::addHorizontalAxis() {
 	Axis* axis = new Axis("x-axis", Axis::AxisHorizontal);
 	if (axis->autoScale()) {
 		axis->setUndoAware(false);
 		axis->setStart(xMin());
 		axis->setEnd(xMax());
 		axis->setUndoAware(true);
 	}
 	addChild(axis);
 }
 
 void CartesianPlot::addVerticalAxis() {
 	Axis* axis = new Axis("y-axis", Axis::AxisVertical);
 	if (axis->autoScale()) {
 		axis->setUndoAware(false);
 		axis->setStart(yMin());
 		axis->setEnd(yMax());
 		axis->setUndoAware(true);
 	}
 	addChild(axis);
 }
 
 void CartesianPlot::addCurve() {
 	addChild(new XYCurve("xy-curve"));
 }
 
 void CartesianPlot::addEquationCurve() {
 	addChild(new XYEquationCurve("f(x)"));
 }
 
 void CartesianPlot::addHistogram() {
 	addChild(new Histogram("Histogram"));
 }
 
 /*!
  * returns the first selected XYCurve in the plot
  */
 const XYCurve* CartesianPlot::currentCurve() const {
 	for (const auto* curve : this->children<const XYCurve>()) {
 		if (curve->graphicsItem()->isSelected())
 			return curve;
 	}
 
 	return nullptr;
 }
 
 void CartesianPlot::addDataReductionCurve() {
 	XYDataReductionCurve* curve = new XYDataReductionCurve("Data reduction");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: reduce '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Reduction of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->dataReductionDataChanged(curve->dataReductionData());
 	} else {
 		beginMacro(i18n("%1: add data reduction curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addDifferentiationCurve() {
 	XYDifferentiationCurve* curve = new XYDifferentiationCurve("Differentiation");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: differentiate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Derivative of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->differentiationDataChanged(curve->differentiationData());
 	} else {
 		beginMacro(i18n("%1: add differentiation curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addIntegrationCurve() {
 	XYIntegrationCurve* curve = new XYIntegrationCurve("Integration");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: integrate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Integral of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->integrationDataChanged(curve->integrationData());
 	} else {
 		beginMacro(i18n("%1: add integration curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addInterpolationCurve() {
 	XYInterpolationCurve* curve = new XYInterpolationCurve("Interpolation");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: interpolate '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Interpolation of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		curve->recalculate();
 		this->addChild(curve);
 		emit curve->interpolationDataChanged(curve->interpolationData());
 	} else {
 		beginMacro(i18n("%1: add interpolation curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addSmoothCurve() {
 	XYSmoothCurve* curve = new XYSmoothCurve("Smooth");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: smooth '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Smoothing of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 		curve->recalculate();
 		emit curve->smoothDataChanged(curve->smoothData());
 	} else {
 		beginMacro(i18n("%1: add smoothing curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFitCurve() {
 	DEBUG("CartesianPlot::addFitCurve()");
 	XYFitCurve* curve = new XYFitCurve("fit");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: fit to '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Fit to '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 
 
 		//set the fit model category and type
 		const auto* action = qobject_cast<const QAction*>(QObject::sender());
 		PlotDataDialog::AnalysisAction type = (PlotDataDialog::AnalysisAction)action->data().toInt();
 		curve->initFitData(type);
 		curve->initStartValues(curCurve);
 
 		//fit with weights for y if the curve has error bars for y
 		if (curCurve->yErrorType() == XYCurve::SymmetricError && curCurve->yErrorPlusColumn()) {
 			XYFitCurve::FitData fitData = curve->fitData();
 			fitData.yWeightsType = nsl_fit_weight_instrumental;
 			curve->setFitData(fitData);
 			curve->setYErrorColumn(curCurve->yErrorPlusColumn());
 		}
 
 		curve->recalculate();
 
 		//add the child after the fit was calculated so the dock widgets gets the fit results
 		//and call retransform() after this to calculate and to paint the data points of the fit-curve
 		this->addChild(curve);
 		curve->retransform();
 	} else {
 		beginMacro(i18n("%1: add fit curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFourierFilterCurve() {
 	XYFourierFilterCurve* curve = new XYFourierFilterCurve("Fourier filter");
 	const XYCurve* curCurve = currentCurve();
 	if (curCurve) {
 		beginMacro( i18n("%1: Fourier filtering of '%2'", name(), curCurve->name()) );
 		curve->setName( i18n("Fourier filtering of '%1'", curCurve->name()) );
 		curve->setDataSourceType(XYAnalysisCurve::DataSourceCurve);
 		curve->setDataSourceCurve(curCurve);
 		this->addChild(curve);
 	} else {
 		beginMacro(i18n("%1: add Fourier filter curve", name()));
 		this->addChild(curve);
 	}
 
 	endMacro();
 }
 
 void CartesianPlot::addFourierTransformCurve() {
 	XYFourierTransformCurve* curve = new XYFourierTransformCurve("Fourier transform");
 	this->addChild(curve);
 }
 
 void CartesianPlot::addConvolutionCurve() {
 	XYConvolutionCurve* curve = new XYConvolutionCurve("Convolution");
 	this->addChild(curve);
 }
 
 void CartesianPlot::addCorrelationCurve() {
 	XYCorrelationCurve* curve = new XYCorrelationCurve("Auto-/Cross-Correlation");
 	this->addChild(curve);
 }
 
 /*!
  * public helper function to set a legend object created outside of CartesianPlot, e.g. in \c OriginProjectParser.
  */
 void CartesianPlot::addLegend(CartesianPlotLegend* legend) {
 	m_legend = legend;
 	this->addChild(legend);
 }
 
 void CartesianPlot::addLegend() {
 	//don't do anything if there's already a legend
 	if (m_legend)
 		return;
 
 	m_legend = new CartesianPlotLegend(this, "legend");
 	this->addChild(m_legend);
 	m_legend->retransform();
 
 	//only one legend is allowed -> disable the action
 	if (m_menusInitialized)
 		addLegendAction->setEnabled(false);
 }
 
 void CartesianPlot::addTextLabel() {
 	TextLabel* label = new TextLabel("text label");
 	this->addChild(label);
 	label->setParentGraphicsItem(graphicsItem());
 }
 
+void CartesianPlot::addImage() {
+	Image* image = new Image("image");
+	this->addChild(image);
+}
+
 void CartesianPlot::addCustomPoint() {
 	CustomPoint* point = new CustomPoint(this, "custom point");
 	this->addChild(point);
 }
 
 int CartesianPlot::curveCount(){
 	return children<XYCurve>().length();
 }
 
 const XYCurve* CartesianPlot::getCurve(int index){
 	return children<XYCurve>()[index];
 }
 
 double CartesianPlot::cursorPos(int cursorNumber) {
 	Q_D(CartesianPlot);
 	if (cursorNumber == 0)
 		return d->cursor0Pos.x();
 	else
 		return d->cursor1Pos.x();
 }
 
 void CartesianPlot::childAdded(const AbstractAspect* child) {
 	Q_D(CartesianPlot);
 	const auto* curve = qobject_cast<const XYCurve*>(child);
 	if (curve) {
 		connect(curve, &XYCurve::dataChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::xDataChanged, this, &CartesianPlot::xDataChanged);
 		connect(curve, &XYCurve::xErrorTypeChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::xErrorPlusColumnChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::xErrorMinusColumnChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::yDataChanged, this, &CartesianPlot::yDataChanged);
 		connect(curve, &XYCurve::yErrorTypeChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::yErrorPlusColumnChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, &XYCurve::yErrorMinusColumnChanged, this, &CartesianPlot::dataChanged);
 		connect(curve, static_cast<void (XYCurve::*)(bool)>(&XYCurve::visibilityChanged),
 				this, &CartesianPlot::curveVisibilityChanged);
 
 		//update the legend on changes of the name, line and symbol styles
 		connect(curve, &XYCurve::aspectDescriptionChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::aspectDescriptionChanged, this, &CartesianPlot::curveNameChanged);
 		connect(curve, &XYCurve::lineTypeChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::linePenChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::linePenChanged, this, static_cast<void (CartesianPlot::*)(QPen)>(&CartesianPlot::curveLinePenChanged));
 		connect(curve, &XYCurve::lineOpacityChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsStyleChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsSizeChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsRotationAngleChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsOpacityChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsBrushChanged, this, &CartesianPlot::updateLegend);
 		connect(curve, &XYCurve::symbolsPenChanged, this, &CartesianPlot::updateLegend);
 
 		updateLegend();
 		d->curvesXMinMaxIsDirty = true;
 		d->curvesYMinMaxIsDirty = true;
 
 		//in case the first curve is added, check whether we start plotting datetime data
 		if (children<XYCurve>().size() == 1) {
 			const auto* col = dynamic_cast<const Column*>(curve->xColumn());
 			if (col) {
 				if (col->columnMode() == AbstractColumn::DateTime) {
 					setUndoAware(false);
 					setXRangeFormat(CartesianPlot::DateTime);
 					setUndoAware(true);
 
 					//set column's datetime format for all horizontal axis
 					for (auto* axis : children<Axis>()) {
 						if (axis->orientation() == Axis::AxisHorizontal) {
 							auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 							d->xRangeDateTimeFormat = filter->format();
 							axis->setUndoAware(false);
 							axis->setLabelsDateTimeFormat(d->xRangeDateTimeFormat);
 							axis->setUndoAware(true);
 						}
 					}
 				}
 			}
 
 			col = dynamic_cast<const Column*>(curve->yColumn());
 			if (col) {
 				if (col->columnMode() == AbstractColumn::DateTime) {
 					setUndoAware(false);
 					setYRangeFormat(CartesianPlot::DateTime);
 					setUndoAware(true);
 
 					//set column's datetime format for all vertical axis
 					for (auto* axis : children<Axis>()) {
 						if (axis->orientation() == Axis::AxisVertical) {
 							auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 							d->yRangeDateTimeFormat = filter->format();
 							axis->setUndoAware(false);
 							axis->setLabelsDateTimeFormat(d->yRangeDateTimeFormat);
 							axis->setUndoAware(true);
 						}
 					}
 				}
 			}
 		}
 		emit curveAdded(curve);
 
 	} else {
 		const auto* hist = qobject_cast<const Histogram*>(child);
 		if (hist) {
 			connect(hist, &Histogram::dataChanged, this, &CartesianPlot::dataChanged);
 			connect(hist, &Histogram::visibilityChanged, this, &CartesianPlot::curveVisibilityChanged);
 
 			updateLegend();
 		}
 		// if an element is hovered, the curves which are handled manually in this class
 		// must be unhovered
 		const auto* element = static_cast<const WorksheetElement*>(child);
 		connect(element, &WorksheetElement::hovered, this, &CartesianPlot::childHovered);
 	}
 
 	if (!isLoading()) {
 		//if a theme was selected, apply the theme settings for newly added children, too
 		if (!d->theme.isEmpty()) {
 			const auto* elem = dynamic_cast<const WorksheetElement*>(child);
 			if (elem) {
 				KConfig config(ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig);
 				const_cast<WorksheetElement*>(elem)->loadThemeConfig(config);
 			}
 		} else {
 			//no theme is available, apply the default colors for curves only, s.a. XYCurve::loadThemeConfig()
 			const auto* curve = dynamic_cast<const XYCurve*>(child);
 			if (curve) {
 				int index = indexOfChild<XYCurve>(curve);
 				QColor themeColor;
 				if (index < m_themeColorPalette.size())
 					themeColor = m_themeColorPalette.at(index);
 				else {
 					if (m_themeColorPalette.size())
 						themeColor = m_themeColorPalette.last();
 				}
 
 				auto* c = const_cast<XYCurve*>(curve);
 
 				//Line
 				QPen p = curve->linePen();
 				p.setColor(themeColor);
 				c->setLinePen(p);
 
 				//Drop line
 				p = curve->dropLinePen();
 				p.setColor(themeColor);
 				c->setDropLinePen(p);
 
 				//Symbol
 				QBrush brush = c->symbolsBrush();
 				brush.setColor(themeColor);
 				c->setSymbolsBrush(brush);
 				p = c->symbolsPen();
 				p.setColor(themeColor);
 				c->setSymbolsPen(p);
 
 				//Filling
 				c->setFillingFirstColor(themeColor);
 
 				//Error bars
 				p.setColor(themeColor);
 				c->setErrorBarsPen(p);
 			}
 		}
 	}
 }
 
 void CartesianPlot::childRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child) {
 	Q_UNUSED(parent);
 	Q_UNUSED(before);
 	if (m_legend == child) {
 		if (m_menusInitialized)
 			addLegendAction->setEnabled(true);
 		m_legend = nullptr;
 	} else {
 		const auto* curve = qobject_cast<const XYCurve*>(child);
 		if (curve) {
 			updateLegend();
 			emit curveRemoved(curve);
 		}
 	}
 }
 
 /*!
  * \brief CartesianPlot::childHovered
  * Unhover all curves, when another child is hovered. The hover handling for the curves is done in their parent (CartesianPlot),
  * because the hover should set when the curve is hovered and not just the bounding rect (for more see hoverMoveEvent)
  */
 void CartesianPlot::childHovered() {
 	Q_D(CartesianPlot);
 	bool curveSender = dynamic_cast<XYCurve*>(QObject::sender()) != nullptr;
 	if (!d->isSelected()) {
 		if (d->m_hovered)
 			d->m_hovered = false;
 		d->update();
 	}
 	if (!curveSender) {
 		for (auto curve: children<XYCurve>())
 			curve->setHover(false);
 	}
 }
 
 void CartesianPlot::updateLegend() {
 	if (m_legend)
 		m_legend->retransform();
 }
 
 /*!
 	called when in one of the curves the data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::dataChanged() {
 	Q_D(CartesianPlot);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	bool updated = false;
 	if (d->autoScaleX && d->autoScaleY)
 		updated = scaleAuto();
 	else if (d->autoScaleX)
 		updated = scaleAutoX();
 	else if (d->autoScaleY)
 		updated = scaleAutoY();
 
 	if (!updated || !QObject::sender()) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->retransform();
 			else {
 				//no sender available, the function was called directly in the file filter (live data source got new data)
 				//or in Project::load() -> retransform all available curves since we don't know which curves are affected.
 				//TODO: this logic can be very expensive
 				for (auto* c : children<XYCurve>()) {
 					c->recalcLogicalPoints();
 					c->retransform();
 				}
 			}
 		}
 	}
 }
 
 /*!
 	called when in one of the curves the x-data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::xDataChanged() {
 	if (project() && project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesXMinMaxIsDirty = true;
 	bool updated = false;
 	if (d->autoScaleX)
 		updated = this->scaleAutoX();
 
 	if (!updated) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->retransform();
 		}
 	}
 
 	//in case there is only one curve and its column mode was changed, check whether we start plotting datetime data
 	if (children<XYCurve>().size() == 1) {
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		const AbstractColumn* col = curve->xColumn();
 		if (col->columnMode() == AbstractColumn::DateTime && d->xRangeFormat != CartesianPlot::DateTime) {
 			setUndoAware(false);
 			setXRangeFormat(CartesianPlot::DateTime);
 			setUndoAware(true);
 		}
 	}
 	emit curveDataChanged(dynamic_cast<XYCurve*>(QObject::sender()));
 }
 
 /*!
 	called when in one of the curves the x-data was changed.
 	Autoscales the coordinate system and the x-axes, when "auto-scale" is active.
 */
 void CartesianPlot::yDataChanged() {
 	if (project() && project()->isLoading())
 		return;
 
 	Q_D(CartesianPlot);
 	if (d->suppressRetransform)
 		return;
 
 	d->curvesYMinMaxIsDirty = true;
 	bool updated = false;
 	if (d->autoScaleY)
 		updated = this->scaleAutoY();
 
 	if (!updated) {
 		//even if the plot ranges were not changed, either no auto scale active or the new data
 		//is within the current ranges and no change of the ranges is required,
 		//retransform the curve in order to show the changes
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		if (curve)
 			curve->retransform();
 		else {
 			auto* hist = dynamic_cast<Histogram*>(QObject::sender());
 			if (hist)
 				hist->retransform();
 		}
 	}
 
 	//in case there is only one curve and its column mode was changed, check whether we start plotting datetime data
 	if (children<XYCurve>().size() == 1) {
 		auto* curve = dynamic_cast<XYCurve*>(QObject::sender());
 		const AbstractColumn* col = curve->yColumn();
 		if (col->columnMode() == AbstractColumn::DateTime && d->xRangeFormat != CartesianPlot::DateTime) {
 			setUndoAware(false);
 			setYRangeFormat(CartesianPlot::DateTime);
 			setUndoAware(true);
 		}
 	}
 	emit curveDataChanged(dynamic_cast<XYCurve*>(QObject::sender()));
 }
 
 void CartesianPlot::curveVisibilityChanged() {
 	Q_D(CartesianPlot);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	updateLegend();
 	if (d->autoScaleX && d->autoScaleY)
 		this->scaleAuto();
 	else if (d->autoScaleX)
 		this->scaleAutoX();
 	else if (d->autoScaleY)
 		this->scaleAutoY();
 
 	emit curveVisibilityChangedSignal();
 }
 
 void CartesianPlot::curveLinePenChanged(QPen pen) {
 	const auto* curve = qobject_cast<const XYCurve*>(QObject::sender());
 	emit curveLinePenChanged(pen, curve->name());
 }
 
 void CartesianPlot::setMouseMode(const MouseMode mouseMode) {
 	Q_D(CartesianPlot);
 
 	d->mouseMode = mouseMode;
 	d->setHandlesChildEvents(mouseMode != CartesianPlot::SelectionMode);
 
 	QList<QGraphicsItem*> items = d->childItems();
 	if (d->mouseMode == CartesianPlot::SelectionMode) {
 		d->setZoomSelectionBandShow(false);
 		d->setCursor(Qt::ArrowCursor);
 		for (auto* item : items)
 			item->setFlag(QGraphicsItem::ItemStacksBehindParent, false);
 	} else {
 		for (auto* item : items)
 			item->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
 	}
 
 	//when doing zoom selection, prevent the graphics item from being movable
 	//if it's currently movable (no worksheet layout available)
 	const auto* worksheet = dynamic_cast<const Worksheet*>(parentAspect());
 	if (worksheet) {
 		if (mouseMode == CartesianPlot::SelectionMode) {
 			if (worksheet->layout() != Worksheet::NoLayout)
 				graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 			else
 				graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, true);
 		} else   //zoom m_selection
 			graphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 	}
 
 	emit mouseModeChanged(mouseMode);
 }
 
 void CartesianPlot::setLocked(bool locked) {
 	Q_D(CartesianPlot);
 	d->locked = locked;
 }
 
 bool CartesianPlot::scaleAutoX() {
 	Q_D(CartesianPlot);
 	if (d->curvesXMinMaxIsDirty) {
 		calculateCurvesXMinMax(false);
 
 		//loop over all histograms and determine the maximum and minimum x-values
 		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 			if (!curve->dataColumn())
 				continue;
 
 			const double min = curve->getXMinimum();
 			if (min < d->curvesXMin)
 				d->curvesXMin = min;
 
 			const double max = curve->getXMaximum();
 			if (max > d->curvesXMax)
 				d->curvesXMax = max;
 		}
 
 		// do it at the end, because it must be from the real min/max values
 		double errorBarsCapSize = -1;
 		for (auto* curve : this->children<const XYCurve>()) {
 			if (curve->yErrorType() != XYCurve::ErrorType::NoError) {
 				errorBarsCapSize = qMax(errorBarsCapSize, curve->errorBarsCapSize());
 			}
 		}
 
 		if (errorBarsCapSize > 0) {
 			// must be done, because retransformScales uses xMin/xMax
 			if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY)
 				d->xMin = d->curvesXMin;
 
 			if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY)
 				d->xMax = d->curvesXMax;
 			// When the previous scale is completely different. The mapTo functions scale with wrong values. To prevent
 			// this a rescale must be done.
 			// The errorBarsCapSize is in Scene coordinates. So this value must be transformed into a logical value. Due
 			// to nonlinear scalings it cannot only be multiplied with a scaling factor and depends on the position of the
 			// column value
 			// dirty hack: call setIsLoading(true) to suppress the call of retransform() in retransformScales() since a
 			// retransform is already done at the end of this function
 			setIsLoading(true);
 			d->retransformScales();
 			setIsLoading(false);
 			QPointF point = coordinateSystem()->mapLogicalToScene(QPointF(d->curvesXMin, 0), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setX(point.x() - errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			// Problem is, when the scaling is not linear (for example log(x)) and the minimum is 0. In this
 			// case mapLogicalToScene returns (0,0) which is smaller than the curves minimum
 			if (point.x() < d->curvesXMin)
 				d->curvesXMin = point.x();
 
 			point = coordinateSystem()->mapLogicalToScene(QPointF(d->curvesXMax, 0), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setX(point.x() + errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.x() > d->curvesXMax)
 				d->curvesXMax = point.x();
 		}
 		d->curvesYMinMaxIsDirty = true;
 		d->curvesXMinMaxIsDirty = false;
 	}
 
 	bool update = false;
 	if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY) {
 		d->xMin = d->curvesXMin;
 		update = true;
 	}
 
 	if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY) {
 		d->xMax = d->curvesXMax;
 		update = true;
 	}
 
 	if (update) {
 		if (d->xMax == d->xMin) {
 			//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 			if (d->xMax != 0) {
 				d->xMax = d->xMax*1.1;
 				d->xMin = d->xMin*0.9;
 			} else {
 				d->xMax = 0.1;
 				d->xMin = -0.1;
 			}
 		} else {
 			double offset = (d->xMax - d->xMin)*d->autoScaleOffsetFactor;
 			d->xMin -= offset;
 			d->xMax += offset;
 		}
 		d->retransformScales();
 	}
 
 	return update;
 }
 
 bool CartesianPlot::scaleAutoY() {
 	Q_D(CartesianPlot);
 
 	if (d->curvesYMinMaxIsDirty) {
 		calculateCurvesYMinMax(false); // loop over all curves
 
 		//loop over all histograms and determine the maximum y-value
 		for (const auto* curve : this->children<const Histogram>()) {
 			if (!curve->isVisible())
 				continue;
 
 			const double min = curve->getYMinimum();
 			if (d->curvesYMin > min)
 				d->curvesYMin = min;
 
 			const double max = curve->getYMaximum();
 			if (max > d->curvesYMax)
 				d->curvesYMax = max;
 		}
 
 		// do it at the end, because it must be from the real min/max values
 		double errorBarsCapSize = -1;
 		for (auto* curve : this->children<const XYCurve>()) {
 			if (curve->xErrorType() != XYCurve::ErrorType::NoError) {
 				errorBarsCapSize = qMax(errorBarsCapSize, curve->errorBarsCapSize());
 			}
 		}
 
 		if (errorBarsCapSize > 0) {
 			if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY)
 				d->yMin = d->curvesYMin;
 
 			if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY)
 				d->yMax = d->curvesYMax;
 			setIsLoading(true);
 			d->retransformScales();
 			setIsLoading(false);
 			QPointF point = coordinateSystem()->mapLogicalToScene(QPointF(0, d->curvesYMin), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setY(point.y() + errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.y() < d->curvesYMin)
 				d->curvesYMin = point.y();
 
 			point = coordinateSystem()->mapLogicalToScene(QPointF(0, d->curvesYMax), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setY(point.y() - errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.y() > d->curvesYMax)
 				d->curvesYMax = point.y();
 		}
 
 		d->curvesXMinMaxIsDirty = true;
 		d->curvesYMinMaxIsDirty = false;
 	}
 
 	bool update = false;
 	if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY) {
 		d->yMin = d->curvesYMin;
 		update = true;
 	}
 
 	if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY) {
 		d->yMax = d->curvesYMax;
 		update = true;
 	}
 	if (update) {
 		if (d->yMax == d->yMin) {
 			//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 			if (d->yMax != 0) {
 				d->yMax = d->yMax*1.1;
 				d->yMin = d->yMin*0.9;
 			} else {
 				d->yMax = 0.1;
 				d->yMin = -0.1;
 			}
 		} else {
 			double offset = (d->yMax - d->yMin)*d->autoScaleOffsetFactor;
 			d->yMin -= offset;
 			d->yMax += offset;
 		}
 		d->retransformScales();
 	}
 
 	return update;
 }
 
 void CartesianPlot::scaleAutoTriggered() {
 	QAction* action = dynamic_cast<QAction*>(QObject::sender());
 	if (!action)
 		return;
 
 	if (action == scaleAutoAction)
 		scaleAuto();
 	else if (action == scaleAutoXAction)
 		setAutoScaleX(true);
 	else if (action == scaleAutoYAction)
 		setAutoScaleY(true);
 }
 
 bool CartesianPlot::scaleAuto() {
 	DEBUG("CartesianPlot::scaleAuto()");
 	Q_D(CartesianPlot);
 
 	if (d->curvesXMinMaxIsDirty) {
 		calculateCurvesXMinMax();
 		double errorBarsCapSize = -1;
 		for (auto* curve : this->children<const XYCurve>()) {
 			if (curve->yErrorType() != XYCurve::ErrorType::NoError) {
 				errorBarsCapSize = qMax(errorBarsCapSize, curve->errorBarsCapSize());
 			}
 		}
 
 		if (errorBarsCapSize > 0) {
 			if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY)
 				d->xMin = d->curvesXMin;
 
 			if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY)
 				d->xMax = d->curvesXMax;
 			setIsLoading(true);
 			d->retransformScales();
 			setIsLoading(false);
 			QPointF point = coordinateSystem()->mapLogicalToScene(QPointF(d->curvesXMin, 0), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setX(point.x() - errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.x() < d->curvesXMin)
 				d->curvesXMin = point.x();
 
 			point = coordinateSystem()->mapLogicalToScene(QPointF(d->curvesXMax, 0), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setX(point.x() + errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.x() > d->curvesXMax)
 				d->curvesXMax = point.x();
 		}
 		d->curvesXMinMaxIsDirty = false;
 	}
 
 	if (d->curvesYMinMaxIsDirty) {
 		calculateCurvesYMinMax();
 		double errorBarsCapSize = -1;
 		for (auto* curve : this->children<const XYCurve>()) {
 			if (curve->xErrorType() != XYCurve::ErrorType::NoError) {
 				errorBarsCapSize = qMax(errorBarsCapSize, curve->errorBarsCapSize());
 			}
 		}
 
 		if (errorBarsCapSize > 0) {
 			if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY)
 				d->yMin = d->curvesYMin;
 
 			if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY)
 				d->yMax = d->curvesYMax;
 			setIsLoading(true);
 			d->retransformScales();
 			setIsLoading(false);
 			QPointF point = coordinateSystem()->mapLogicalToScene(QPointF(0, d->curvesYMin), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setY(point.y() + errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.y() < d->curvesYMin)
 				d->curvesYMin = point.y();
 
 			point = coordinateSystem()->mapLogicalToScene(QPointF(0, d->curvesYMax), AbstractCoordinateSystem::SuppressPageClipping);
 			point.setY(point.y() - errorBarsCapSize);
 			point = coordinateSystem()->mapSceneToLogical(point, AbstractCoordinateSystem::SuppressPageClipping);
 			if (point.y() > d->curvesYMax)
 				d->curvesYMax = point.y();
 		}
 		d->curvesYMinMaxIsDirty = false;
 	}
 
 	bool updateX = false;
 	bool updateY = false;
 	if (d->curvesXMin != d->xMin && d->curvesXMin != INFINITY) {
 		d->xMin = d->curvesXMin;
 		updateX = true;
 	}
 
 	if (d->curvesXMax != d->xMax && d->curvesXMax != -INFINITY) {
 		d->xMax = d->curvesXMax;
 		updateX = true;
 	}
 
 	if (d->curvesYMin != d->yMin && d->curvesYMin != INFINITY) {
 		d->yMin = d->curvesYMin;
 		updateY = true;
 	}
 
 	if (d->curvesYMax != d->yMax && d->curvesYMax != -INFINITY) {
 		d->yMax = d->curvesYMax;
 		updateY = true;
 	}
 	DEBUG(" xmin/xmax = " << d->xMin << '/' << d->xMax << ", ymin/ymax = " << d->yMin << '/' << d->yMax);
 
 	if (updateX || updateY) {
 		if (updateX) {
 			if (d->xMax == d->xMin) {
 				//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 				if (d->xMax != 0) {
 					d->xMax = d->xMax*1.1;
 					d->xMin = d->xMin*0.9;
 				} else {
 					d->xMax = 0.1;
 					d->xMin = -0.1;
 				}
 			} else {
 				double offset = (d->xMax - d->xMin)*d->autoScaleOffsetFactor;
 				d->xMin -= offset;
 				d->xMax += offset;
 			}
 			setAutoScaleX(true);
 		}
 		if (updateY) {
 			if (d->yMax == d->yMin) {
 				//in case min and max are equal (e.g. if we plot a single point), subtract/add 10% of the value
 				if (d->yMax != 0) {
 					d->yMax = d->yMax*1.1;
 					d->yMin = d->yMin*0.9;
 				} else {
 					d->yMax = 0.1;
 					d->yMin = -0.1;
 				}
 			} else {
 				double offset = (d->yMax - d->yMin)*d->autoScaleOffsetFactor;
 				d->yMin -= offset;
 				d->yMax += offset;
 			}
 			setAutoScaleY(true);
 		}
 		d->retransformScales();
 	}
 
 	return (updateX || updateY);
 }
 
 /*!
  * Calculates and sets curves y min and max. This function does not respect the range
  * of the y axis
  */
 void CartesianPlot::calculateCurvesXMinMax(bool completeRange) {
 	Q_D(CartesianPlot);
 
 	d->curvesXMin = INFINITY;
 	d->curvesXMax = -INFINITY;
 
 	//loop over all xy-curves and determine the maximum and minimum x-values
 	for (const auto* curve : this->children<const XYCurve>()) {
 		if (!curve->isVisible())
 			continue;
 
 		auto* xColumn = curve->xColumn();
 		if (!xColumn)
 			continue;
 
 		double min = d->curvesXMin;
 		double max = d->curvesXMax;
 
 		int start =0;
 		int end = 0;
 		if (d->rangeType == CartesianPlot::RangeFree && curve->yColumn()
 				&& !completeRange) {
 			curve->yColumn()->indicesMinMax(yMin(), yMax(), start, end);
 			if (end < curve->yColumn()->rowCount())
 				end ++;
 		} else {
 			switch (d->rangeType) {
 			case CartesianPlot::RangeFree:
 				start = 0;
 				end = xColumn->rowCount();
 				break;
 			case CartesianPlot::RangeLast:
 				start = xColumn->rowCount() - d->rangeLastValues;
 				end = xColumn->rowCount();
 				break;
 			case CartesianPlot::RangeFirst:
 				start = 0;
 				end = d->rangeFirstValues;
 				break;
 			}
 		}
 
 		curve->minMaxX(start, end, min, max, true);
 		if (min < d->curvesXMin)
 			d->curvesXMin = min;
 
 		if (max > d->curvesXMax)
 			d->curvesXMax = max;
 	}
 
 	//loop over all histograms and determine the maximum and minimum x-values
 	for (const auto* curve : this->children<const Histogram>()) {
 		if (!curve->isVisible())
 			continue;
 		if (!curve->dataColumn())
 			continue;
 
 		const double min = curve->getXMinimum();
 		if (d->curvesXMin > min)
 			d->curvesXMin = min;
 
 		const double max = curve->getXMaximum();
 		if (max > d->curvesXMax)
 			d->curvesXMax = max;
 	}
 }
 
 /*!
  * Calculates and sets curves y min and max. This function does not respect the range
  * of the x axis
  */
 void CartesianPlot::calculateCurvesYMinMax(bool completeRange) {
 	Q_D(CartesianPlot);
 
 	d->curvesYMin = INFINITY;
 	d->curvesYMax = -INFINITY;
 
 	double min = d->curvesYMin;
 	double max = d->curvesYMax;
 
 
 	//loop over all xy-curves and determine the maximum and minimum y-values
 	for (const auto* curve : this->children<const XYCurve>()) {
 		if (!curve->isVisible())
 			continue;
 
 		auto* yColumn = curve->yColumn();
 		if (!yColumn)
 			continue;
 
 		int start =0;
 		int end = 0;
 		if (d->rangeType == CartesianPlot::RangeFree && curve->xColumn() &&
 				!completeRange) {
 			curve->xColumn()->indicesMinMax(xMin(), xMax(), start, end);
 			if (end < curve->xColumn()->rowCount())
 				end ++; // because minMaxY excludes indexMax
 		} else {
 			switch (d->rangeType) {
 				case CartesianPlot::RangeFree:
 					start = 0;
 					end = yColumn->rowCount();
 					break;
 				case CartesianPlot::RangeLast:
 					start = yColumn->rowCount() - d->rangeLastValues;
 					end = yColumn->rowCount();
 					break;
 				case CartesianPlot::RangeFirst:
 					start = 0;
 					end = d->rangeFirstValues;
 					break;
 			}
 		}
 
 		curve->minMaxY(start, end, min, max, true);
 
 		if (min < d->curvesYMin)
 			d->curvesYMin = min;
 
 		if (max > d->curvesYMax)
 			d->curvesYMax = max;
 	}
 
 	//loop over all histograms and determine the maximum y-value
 	for (const auto* curve : this->children<const Histogram>()) {
 		if (!curve->isVisible())
 			continue;
 
 		const double min = curve->getYMinimum();
 		if (d->curvesYMin > min)
 			d->curvesYMin = min;
 
 		const double max = curve->getYMaximum();
 		if (max > d->curvesYMax)
 			d->curvesYMax = max;
 	}
 
 
 }
 
 void CartesianPlot::zoomIn() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->xMax - d->xMin);
 	double newRange = (d->xMax - d->xMin) / m_zoomFactor;
 	d->xMax = d->xMax + (newRange - oldRange) / 2;
 	d->xMin = d->xMin - (newRange - oldRange) / 2;
 
 	oldRange = (d->yMax - d->yMin);
 	newRange = (d->yMax - d->yMin) / m_zoomFactor;
 	d->yMax = d->yMax + (newRange - oldRange) / 2;
 	d->yMin = d->yMin - (newRange - oldRange) / 2;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOut() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesXMinMaxIsDirty = true;
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)*m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 
 	oldRange = (d->yMax-d->yMin);
 	newRange = (d->yMax-d->yMin)*m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomInX() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)/m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 
 	if (d->autoScaleY && autoScaleY())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOutX() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->xMax-d->xMin);
 	double newRange = (d->xMax-d->xMin)*m_zoomFactor;
 	d->xMax = d->xMax + (newRange-oldRange)/2;
 	d->xMin = d->xMin - (newRange-oldRange)/2;
 
 	if (d->autoScaleY && autoScaleY())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomInY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->yMax-d->yMin);
 	double newRange = (d->yMax-d->yMin)/m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 
 	if (d->autoScaleX && autoScaleX())
 		return;
 	d->retransformScales();
 }
 
 void CartesianPlot::zoomOutY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double oldRange = (d->yMax-d->yMin);
 	double newRange = (d->yMax-d->yMin)*m_zoomFactor;
 	d->yMax = d->yMax + (newRange-oldRange)/2;
 	d->yMin = d->yMin - (newRange-oldRange)/2;
 
 	if (d->autoScaleX && autoScaleX())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftLeftX() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax -= offsetX;
 	d->xMin -= offsetX;
 
 	if (d->autoScaleY && scaleAutoY())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftRightX() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleX(false);
 	setUndoAware(true);
 	d->curvesYMinMaxIsDirty = true;
 	double offsetX = (d->xMax-d->xMin)*0.1;
 	d->xMax += offsetX;
 	d->xMin += offsetX;
 
 	if (d->autoScaleY && scaleAutoY())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftUpY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesXMinMaxIsDirty = true;
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax += offsetY;
 	d->yMin += offsetY;
 
 	if (d->autoScaleX && scaleAutoX())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::shiftDownY() {
 	Q_D(CartesianPlot);
 
 	setUndoAware(false);
 	setAutoScaleY(false);
 	setUndoAware(true);
 	d->curvesXMinMaxIsDirty = true;
 	double offsetY = (d->yMax-d->yMin)*0.1;
 	d->yMax -= offsetY;
 	d->yMin -= offsetY;
 
 	if (d->autoScaleX && scaleAutoX())
 		return;
 
 	d->retransformScales();
 }
 
 void CartesianPlot::cursor() {
 	Q_D(CartesianPlot);
 	d->retransformScales();
 }
 
 void CartesianPlot::mousePressZoomSelectionMode(QPointF logicPos) {
 	Q_D(CartesianPlot);
 	d->mousePressZoomSelectionMode(logicPos);
 }
 void CartesianPlot::mousePressCursorMode(int cursorNumber, QPointF logicPos) {
 	Q_D(CartesianPlot);
 	d->mousePressCursorMode(cursorNumber, logicPos);
 }
 void CartesianPlot::mouseMoveZoomSelectionMode(QPointF logicPos) {
 	Q_D(CartesianPlot);
 	d->mouseMoveZoomSelectionMode(logicPos);
 }
 void CartesianPlot::mouseMoveCursorMode(int cursorNumber, QPointF logicPos) {
 	Q_D(CartesianPlot);
 	d->mouseMoveCursorMode(cursorNumber, logicPos);
 }
 
 void CartesianPlot::mouseReleaseZoomSelectionMode() {
 	Q_D(CartesianPlot);
 	d->mouseReleaseZoomSelectionMode();
 }
 
 void CartesianPlot::mouseHoverZoomSelectionMode(QPointF logicPos) {
 	Q_D(CartesianPlot);
 	d->mouseHoverZoomSelectionMode(logicPos);
 }
 
 void CartesianPlot::mouseHoverOutsideDataRect() {
 	Q_D(CartesianPlot);
 	d->mouseHoverOutsideDataRect();
 }
 
 //##############################################################################
 //######  SLOTs for changes triggered via QActions in the context menu  ########
 //##############################################################################
 void CartesianPlot::visibilityChanged() {
 	Q_D(CartesianPlot);
 	this->setVisible(!d->isVisible());
 }
 
 //#####################################################################
 //################### Private implementation ##########################
 //#####################################################################
 CartesianPlotPrivate::CartesianPlotPrivate(CartesianPlot* plot) : AbstractPlotPrivate(plot), q(plot) {
 	setData(0, WorksheetElement::NameCartesianPlot);
 	m_cursor0Text.prepare();
 	m_cursor1Text.prepare();
 }
 
 /*!
 	updates the position of plot rectangular in scene coordinates to \c r and recalculates the scales.
 	The size of the plot corresponds to the size of the plot area, the area which is filled with the background color etc.
 	and which can pose the parent item for several sub-items (like TextLabel).
 	Note, the size of the area used to define the coordinate system doesn't need to be equal to this plot area.
 	Also, the size (=bounding box) of CartesianPlot can be greater than the size of the plot area.
  */
 void CartesianPlotPrivate::retransform() {
 	if (suppressRetransform)
 		return;
 
 	PERFTRACE("CartesianPlotPrivate::retransform()");
 	prepareGeometryChange();
 	setPos( rect.x()+rect.width()/2, rect.y()+rect.height()/2);
 
 	updateDataRect();
 	retransformScales();
 
 	//plotArea position is always (0, 0) in parent's coordinates, don't need to update here
 	q->plotArea()->setRect(rect);
 
 	//call retransform() for the title and the legend (if available)
 	//when a predefined position relative to the (Left, Centered etc.) is used,
 	//the actual position needs to be updated on plot's geometry changes.
 	if (q->title())
 		q->title()->retransform();
 	if (q->m_legend)
 		q->m_legend->retransform();
 
 	WorksheetElementContainerPrivate::recalcShapeAndBoundingRect();
 }
 
 void CartesianPlotPrivate::retransformScales() {
 	DEBUG("CartesianPlotPrivate::retransformScales()");
 	DEBUG(" xmin/xmax = " << xMin << '/'<< xMax << ", ymin/ymax = " << yMin << '/' << yMax);
 	PERFTRACE("CartesianPlotPrivate::retransformScales()");
 
 	auto* plot = dynamic_cast<CartesianPlot*>(q);
 	QVector<CartesianScale*> scales;
 
 	//check ranges for log-scales
 	if (xScale != CartesianPlot::ScaleLinear)
 		checkXRange();
 
 	//check whether we have x-range breaks - the first break, if available, should be valid
 	bool hasValidBreak = (xRangeBreakingEnabled && !xRangeBreaks.list.isEmpty() && xRangeBreaks.list.first().isValid());
 
 	static const int breakGap = 20;
 	double sceneStart, sceneEnd, logicalStart, logicalEnd;
 
 	//create x-scales
 	int plotSceneStart = dataRect.x();
 	int plotSceneEnd = dataRect.x() + dataRect.width();
 	if (!hasValidBreak) {
 		//no breaks available -> range goes from the plot beginning to the end of the plot
 		sceneStart = plotSceneStart;
 		sceneEnd = plotSceneEnd;
 		logicalStart = xMin;
 		logicalEnd = xMax;
 
 		//TODO: how should we handle the case sceneStart == sceneEnd?
 		//(to reproduce, create plots and adjust the spacing/pading to get zero size for the plots)
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	} else {
 		int sceneEndLast = plotSceneStart;
 		int logicalEndLast = xMin;
 		for (const auto& rb : xRangeBreaks.list) {
 			if (!rb.isValid())
 				break;
 
 			//current range goes from the end of the previous one (or from the plot beginning) to curBreak.start
 			sceneStart = sceneEndLast;
 			if (&rb == &xRangeBreaks.list.first()) sceneStart += breakGap;
 			sceneEnd = plotSceneStart + (plotSceneEnd-plotSceneStart) * rb.position;
 			logicalStart = logicalEndLast;
 			logicalEnd = rb.start;
 
 			if (sceneStart != sceneEnd)
 				scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 
 			sceneEndLast = sceneEnd;
 			logicalEndLast = rb.end;
 		}
 
 		//add the remaining range going from the last available range break to the end of the plot (=end of the x-data range)
 		sceneStart = sceneEndLast+breakGap;
 		sceneEnd = plotSceneEnd;
 		logicalStart = logicalEndLast;
 		logicalEnd = xMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(xScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	}
 
 	cSystem->setXScales(scales);
 
 	//check ranges for log-scales
 	if (yScale != CartesianPlot::ScaleLinear)
 		checkYRange();
 
 	//check whether we have y-range breaks - the first break, if available, should be valid
 	hasValidBreak = (yRangeBreakingEnabled && !yRangeBreaks.list.isEmpty() && yRangeBreaks.list.first().isValid());
 
 	//create y-scales
 	scales.clear();
 	plotSceneStart = dataRect.y() + dataRect.height();
 	plotSceneEnd = dataRect.y();
 	if (!hasValidBreak) {
 		//no breaks available -> range goes from the plot beginning to the end of the plot
 		sceneStart = plotSceneStart;
 		sceneEnd = plotSceneEnd;
 		logicalStart = yMin;
 		logicalEnd = yMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	} else {
 		int sceneEndLast = plotSceneStart;
 		int logicalEndLast = yMin;
 		for (const auto& rb : yRangeBreaks.list) {
 			if (!rb.isValid())
 				break;
 
 			//current range goes from the end of the previous one (or from the plot beginning) to curBreak.start
 			sceneStart = sceneEndLast;
 			if (&rb == &yRangeBreaks.list.first()) sceneStart -= breakGap;
 			sceneEnd = plotSceneStart + (plotSceneEnd-plotSceneStart) * rb.position;
 			logicalStart = logicalEndLast;
 			logicalEnd = rb.start;
 
 			if (sceneStart != sceneEnd)
 				scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 
 			sceneEndLast = sceneEnd;
 			logicalEndLast = rb.end;
 		}
 
 		//add the remaining range going from the last available range break to the end of the plot (=end of the y-data range)
 		sceneStart = sceneEndLast-breakGap;
 		sceneEnd = plotSceneEnd;
 		logicalStart = logicalEndLast;
 		logicalEnd = yMax;
 
 		if (sceneStart != sceneEnd)
 			scales << this->createScale(yScale, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	}
 
 	cSystem->setYScales(scales);
 
 	//calculate the changes in x and y and save the current values for xMin, xMax, yMin, yMax
 	double deltaXMin = 0;
 	double deltaXMax = 0;
 	double deltaYMin = 0;
 	double deltaYMax = 0;
 
 	if (xMin != xMinPrev) {
 		deltaXMin = xMin - xMinPrev;
 		emit plot->xMinChanged(xMin);
 	}
 
 	if (xMax != xMaxPrev) {
 		deltaXMax = xMax - xMaxPrev;
 		emit plot->xMaxChanged(xMax);
 	}
 
 	if (yMin != yMinPrev) {
 		deltaYMin = yMin - yMinPrev;
 		emit plot->yMinChanged(yMin);
 	}
 
 	if (yMax != yMaxPrev) {
 		deltaYMax = yMax - yMaxPrev;
 		emit plot->yMaxChanged(yMax);
 	}
 
 	xMinPrev = xMin;
 	xMaxPrev = xMax;
 	yMinPrev = yMin;
 	yMaxPrev = yMax;
 	//adjust auto-scale axes
 	for (auto* axis : q->children<Axis>()) {
 		if (!axis->autoScale())
 			continue;
 
 		if (axis->orientation() == Axis::AxisHorizontal) {
 			if (deltaXMax != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setEnd(xMax);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			if (deltaXMin != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setStart(xMin);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			//TODO;
 // 			if (axis->position() == Axis::AxisCustom && deltaYMin != 0) {
 // 				axis->setOffset(axis->offset() + deltaYMin, false);
 // 			}
 		} else {
 			if (deltaYMax != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setEnd(yMax);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 			if (deltaYMin != 0) {
 				axis->setUndoAware(false);
 				axis->setSuppressRetransform(true);
 				axis->setStart(yMin);
 				axis->setUndoAware(true);
 				axis->setSuppressRetransform(false);
 			}
 
 			//TODO;
 // 			if (axis->position() == Axis::AxisCustom && deltaXMin != 0) {
 // 				axis->setOffset(axis->offset() + deltaXMin, false);
 // 			}
 		}
 	}
 	// call retransform() on the parent to trigger the update of all axes and curves.
 	//no need to do this on load since all plots are retransformed again after the project is loaded.
 	if (!q->isLoading())
 		q->retransform();
 }
 
 /*
  * calculates the rectangular of the are showing the actual data (plot's rect minus padding),
  * in plot's coordinates.
  */
 void CartesianPlotPrivate::updateDataRect() {
 	dataRect = mapRectFromScene(rect);
 
 	double paddingLeft = horizontalPadding;
 	double paddingRight = rightPadding;
 	double paddingTop = verticalPadding;
 	double paddingBottom = bottomPadding;
 	if (symmetricPadding) {
 		paddingRight = horizontalPadding;
 		paddingBottom = verticalPadding;
 	}
 
 	dataRect.setX(dataRect.x() + paddingLeft);
 	dataRect.setY(dataRect.y() + paddingTop);
 
 	double newHeight = dataRect.height() - paddingBottom;
 	if (newHeight < 0)
 		newHeight = 0;
 	dataRect.setHeight(newHeight);
 
 	double newWidth = dataRect.width() - paddingRight;
 	if (newWidth < 0)
 		newWidth = 0;
 	dataRect.setWidth(newWidth);
 }
 
 void CartesianPlotPrivate::rangeChanged() {
 	curvesXMinMaxIsDirty = true;
 	curvesYMinMaxIsDirty = true;
 	if (autoScaleX && autoScaleY)
 		q->scaleAuto();
 	else if (autoScaleX)
 		q->scaleAutoX();
 	else if (autoScaleY)
 		q->scaleAutoY();
 }
 
 void CartesianPlotPrivate::xRangeFormatChanged() {
 	for (auto* axis : q->children<Axis>()) {
 		if (axis->orientation() == Axis::AxisHorizontal)
 			axis->retransformTickLabelStrings();
 	}
 }
 
 void CartesianPlotPrivate::yRangeFormatChanged() {
 	for (auto* axis : q->children<Axis>()) {
 		if (axis->orientation() == Axis::AxisVertical)
 			axis->retransformTickLabelStrings();
 	}
 }
 
 /*!
  * don't allow any negative values for the x range when log or sqrt scalings are used
  */
 void CartesianPlotPrivate::checkXRange() {
 	double min = 0.01;
 
 	if (xMin <= 0.0) {
 		(min < xMax*min) ? xMin = min : xMin = xMax*min;
 		emit q->xMinChanged(xMin);
 	} else if (xMax <= 0.0) {
 		(-min > xMin*min) ? xMax = -min : xMax = xMin*min;
 		emit q->xMaxChanged(xMax);
 	}
 }
 
 /*!
  * don't allow any negative values for the y range when log or sqrt scalings are used
  */
 void CartesianPlotPrivate::checkYRange() {
 	double min = 0.01;
 
 	if (yMin <= 0.0) {
 		(min < yMax*min) ? yMin = min : yMin = yMax*min;
 		emit q->yMinChanged(yMin);
 	} else if (yMax <= 0.0) {
 		(-min > yMin*min) ? yMax = -min : yMax = yMin*min;
 		emit q->yMaxChanged(yMax);
 	}
 }
 
 CartesianScale* CartesianPlotPrivate::createScale(CartesianPlot::Scale type, double sceneStart, double sceneEnd, double logicalStart, double logicalEnd) {
 	DEBUG("CartesianPlotPrivate::createScale() scene start/end = " << sceneStart << '/' << sceneEnd << ", logical start/end = " << logicalStart << '/' << logicalEnd);
 // 	Interval<double> interval (logicalStart-0.01, logicalEnd+0.01); //TODO: move this to CartesianScale
 	Interval<double> interval (std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max());
 // 	Interval<double> interval (logicalStart, logicalEnd);
 	if (type == CartesianPlot::ScaleLinear)
 		return CartesianScale::createLinearScale(interval, sceneStart, sceneEnd, logicalStart, logicalEnd);
 	else
 		return CartesianScale::createLogScale(interval, sceneStart, sceneEnd, logicalStart, logicalEnd, type);
 }
 
 /*!
  * Reimplemented from QGraphicsItem.
  */
 QVariant CartesianPlotPrivate::itemChange(GraphicsItemChange change, const QVariant &value) {
 	if (change == QGraphicsItem::ItemPositionChange) {
 		const QPointF& itemPos = value.toPointF();//item's center point in parent's coordinates;
 		const qreal x = itemPos.x();
 		const qreal y = itemPos.y();
 
 		//calculate the new rect and forward the changes to the frontend
 		QRectF newRect;
 		const qreal w = rect.width();
 		const qreal h = rect.height();
 		newRect.setX(x-w/2);
 		newRect.setY(y-h/2);
 		newRect.setWidth(w);
 		newRect.setHeight(h);
 		emit q->rectChanged(newRect);
 	}
 	return QGraphicsItem::itemChange(change, value);
 }
 
 //##############################################################################
 //##################################  Events  ##################################
 //##############################################################################
 
 /*!
  * \brief CartesianPlotPrivate::mousePressEvent
  * In this function only basic stuff is done. The mousePressEvent is forwarded to the Worksheet, which
  * has access to all cartesian plots and can apply the changes to all plots if the option "applyToAll"
  * is set. The worksheet calls then the corresponding mousepressZoomMode/CursorMode function in this class
  * This is done for mousePress, mouseMove and mouseRelease event
  * This function sends a signal with the logical position, because this is the only value which is the same
  * in all plots. Using the scene coordinates is not possible
  * \param event
  */
 void CartesianPlotPrivate::mousePressEvent(QGraphicsSceneMouseEvent *event) {
 
 	if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode)
 		emit q->mousePressZoomSelectionModeSignal(cSystem->mapSceneToLogical(event->pos(), AbstractCoordinateSystem::MappingFlag::Limit));
 	else if (mouseMode == CartesianPlot::Cursor) {
 		setCursor(Qt::SizeHorCursor);
 		QPointF logicalPos = cSystem->mapSceneToLogical(event->pos(), AbstractCoordinateSystem::MappingFlag::Limit);
 		double cursorPenWidth2 = cursorPen.width()/2.;
 		if (cursorPenWidth2 < 10.)
 			cursorPenWidth2 = 10.;
 		if (cursor0Enable && qAbs(event->pos().x()-cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMin)).x()) < cursorPenWidth2) {
 			selectedCursor = 0;
 		} else if (cursor1Enable && qAbs(event->pos().x()-cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMin)).x()) < cursorPenWidth2) {
 			selectedCursor = 1;
 		} else if (QApplication::keyboardModifiers() & Qt::ControlModifier){
 			cursor1Enable = true;
 			selectedCursor = 1;
 			emit q->cursor1EnableChanged(cursor1Enable);
 		} else {
 			cursor0Enable = true;
 			selectedCursor = 0;
 			emit q->cursor0EnableChanged(cursor0Enable);
 		}
 		emit q->mousePressCursorModeSignal(selectedCursor, logicalPos);
 
 	} else {
 		if (!locked && dataRect.contains(event->pos())) {
 			panningStarted = true;
 			m_panningStart = event->pos();
 			setCursor(Qt::ClosedHandCursor);
 		}
 	}
 	QGraphicsItem::mousePressEvent(event);
 }
 
 void CartesianPlotPrivate::mousePressZoomSelectionMode(QPointF logicalPos) {
 	if (mouseMode == CartesianPlot::ZoomSelectionMode) {
 
 		if (logicalPos.x() < xMin)
 			logicalPos.setX(xMin);
 
 		if (logicalPos.x() > xMax)
 			logicalPos.setX(xMax);
 
 		if (logicalPos.y() < yMin)
 			logicalPos.setY(yMin);
 
 		if (logicalPos.y() > yMax)
 			logicalPos.setY(yMax);
 
 		m_selectionStart = cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping);
 
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 		logicalPos.setY(yMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionStart.setX(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping).x());
 		m_selectionStart.setY(dataRect.y());
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		logicalPos.setX(xMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionStart.setX(dataRect.x());
 		m_selectionStart.setY(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::SuppressPageClipping).y());
 	}
 	m_selectionEnd = m_selectionStart;
 	m_selectionBandIsShown = true;
 }
 
 void CartesianPlotPrivate::mousePressCursorMode(int cursorNumber, QPointF logicalPos) {
 
 	cursorNumber == 0 ? cursor0Enable = true : cursor1Enable = true;
 
 	QPointF p1(logicalPos.x(), yMin);
 	QPointF p2(logicalPos.x(), yMax);
 
 	if (cursorNumber == 0) {
 		cursor0Pos.setX(logicalPos.x());
 		cursor0Pos.setY(0);
 	} else {
 		cursor1Pos.setX(logicalPos.x());
 		cursor1Pos.setY(0);
 	}
 	update();
 }
 
 void CartesianPlotPrivate::updateCursor() {
 	update();
 }
 
 void CartesianPlotPrivate::setZoomSelectionBandShow(bool show) {
 	m_selectionBandIsShown = show;
 }
 
 void CartesianPlotPrivate::mouseMoveEvent(QGraphicsSceneMouseEvent* event) {
 
 	if (mouseMode == CartesianPlot::SelectionMode) {
 		if (panningStarted && dataRect.contains(event->pos()) ) {
 			//don't retransform on small mouse movement deltas
 			const int deltaXScene = (m_panningStart.x() - event->pos().x());
 			const int deltaYScene = (m_panningStart.y() - event->pos().y());
 			if (abs(deltaXScene) < 5 && abs(deltaYScene) < 5)
 				return;
 
 			const QPointF logicalEnd = cSystem->mapSceneToLogical(event->pos());
 			const QPointF logicalStart = cSystem->mapSceneToLogical(m_panningStart);
 			const float deltaX = (logicalStart.x() - logicalEnd.x());
 			const float deltaY = (logicalStart.y() - logicalEnd.y());
 			xMax += deltaX;
 			xMin += deltaX;
 			yMax += deltaY;
 			yMin += deltaY;
 
 			q->setUndoAware(false);
 			q->setAutoScaleX(false);
 			q->setAutoScaleY(false);
 			q->setUndoAware(true);
 
 			retransformScales();
 			m_panningStart = event->pos();
 		} else
 			QGraphicsItem::mouseMoveEvent(event);
 	} else if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		QGraphicsItem::mouseMoveEvent(event);
 		if ( !boundingRect().contains(event->pos()) ) {
 			q->info(QString());
 			return;
 		}
 		emit q->mouseMoveZoomSelectionModeSignal(cSystem->mapSceneToLogical(event->pos(), CartesianCoordinateSystem::MappingFlag::Limit));
 
 	} else if (mouseMode == CartesianPlot::Cursor) {
 		QGraphicsItem::mouseMoveEvent(event);
 		if (!boundingRect().contains(event->pos())) {
 			q->info(i18n("Not inside of the bounding rect"));
 			return;
 		}
 		QPointF logicalPos = cSystem->mapSceneToLogical(event->pos(), AbstractCoordinateSystem::MappingFlag::Limit);
 
 		// updating treeview data and cursor position
 		// updatign cursor position is done in Worksheet, because
 		// multiple plots must be updated
 		emit q->mouseMoveCursorModeSignal(selectedCursor, logicalPos);
 	}
 }
 
 void CartesianPlotPrivate::mouseMoveZoomSelectionMode(QPointF logicalPos) {
 	QString info;
 	QPointF logicalStart = cSystem->mapSceneToLogical(m_selectionStart, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 	if (mouseMode == CartesianPlot::ZoomSelectionMode) {
 		m_selectionEnd = cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping);
 		QPointF logicalEnd = logicalPos;
 		if (xRangeFormat == CartesianPlot::Numeric)
 			info = QString::fromUtf8("Δx=") + QString::number(logicalEnd.x()-logicalStart.x());
 		else
 			info = i18n("from x=%1 to x=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.x()).toString(xRangeDateTimeFormat),
 						QDateTime::fromMSecsSinceEpoch(logicalEnd.x()).toString(xRangeDateTimeFormat));
 
 		info += QLatin1String(", ");
 		if (yRangeFormat == CartesianPlot::Numeric)
 			info += QString::fromUtf8("Δy=") + QString::number(logicalEnd.y()-logicalStart.y());
 		else
 			info += i18n("from y=%1 to y=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.y()).toString(xRangeDateTimeFormat),
 						 QDateTime::fromMSecsSinceEpoch(logicalEnd.y()).toString(xRangeDateTimeFormat));
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 		logicalPos.setY(yMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionEnd.setX(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping).x());//event->pos().x());
 		m_selectionEnd.setY(dataRect.bottom());
 		QPointF logicalEnd = logicalPos;
 		if (xRangeFormat == CartesianPlot::Numeric)
 			info = QString::fromUtf8("Δx=") + QString::number(logicalEnd.x()-logicalStart.x());
 		else
 			info = i18n("from x=%1 to x=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.x()).toString(xRangeDateTimeFormat),
 						QDateTime::fromMSecsSinceEpoch(logicalEnd.x()).toString(xRangeDateTimeFormat));
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		m_selectionEnd.setX(dataRect.right());
 		logicalPos.setX(xMin); // must be done, because the other plots can have other ranges, value must be in the scenes
 		m_selectionEnd.setY(cSystem->mapLogicalToScene(logicalPos, CartesianCoordinateSystem::MappingFlag::SuppressPageClipping).y());//event->pos().y());
 		QPointF logicalEnd = logicalPos;
 		if (yRangeFormat == CartesianPlot::Numeric)
 			info = QString::fromUtf8("Δy=") + QString::number(logicalEnd.y()-logicalStart.y());
 		else
 			info = i18n("from y=%1 to y=%2", QDateTime::fromMSecsSinceEpoch(logicalStart.y()).toString(xRangeDateTimeFormat),
 						QDateTime::fromMSecsSinceEpoch(logicalEnd.y()).toString(xRangeDateTimeFormat));
 	}
 	q->info(info);
 	update();
 }
 
 void CartesianPlotPrivate::mouseMoveCursorMode(int cursorNumber, QPointF logicalPos) {
 
 	QPointF p1(logicalPos.x(), 0);
 	cursorNumber == 0 ? cursor0Pos = p1 : cursor1Pos = p1;
 
 	QString info;
 	if (xRangeFormat == CartesianPlot::Numeric)
 		info = QString::fromUtf8("x=") + QString::number(logicalPos.x());
 	else
 		info = i18n("x=%1", QDateTime::fromMSecsSinceEpoch(logicalPos.x()).toString(xRangeDateTimeFormat));
 	q->info(info);
 	update();
 }
 
 void CartesianPlotPrivate::mouseReleaseEvent(QGraphicsSceneMouseEvent* event) {
 	setCursor(Qt::ArrowCursor);
 	if (mouseMode == CartesianPlot::SelectionMode) {
 		panningStarted = false;
 
 		//TODO: why do we do this all the time?!?!
 		const QPointF& itemPos = pos();//item's center point in parent's coordinates;
 		const qreal x = itemPos.x();
 		const qreal y = itemPos.y();
 
 		//calculate the new rect and set it
 		QRectF newRect;
 		const qreal w = rect.width();
 		const qreal h = rect.height();
 		newRect.setX(x-w/2);
 		newRect.setY(y-h/2);
 		newRect.setWidth(w);
 		newRect.setHeight(h);
 
 		suppressRetransform = true;
 		q->setRect(newRect);
 		suppressRetransform = false;
 
 		QGraphicsItem::mouseReleaseEvent(event);
 	} else if (mouseMode == CartesianPlot::ZoomSelectionMode || mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		emit q->mouseReleaseZoomSelectionModeSignal();
 	}
 }
 
 void CartesianPlotPrivate::mouseReleaseZoomSelectionMode() {
 	//don't zoom if very small region was selected, avoid occasional/unwanted zooming
 	if ( qAbs(m_selectionEnd.x()-m_selectionStart.x()) < 20 || qAbs(m_selectionEnd.y()-m_selectionStart.y()) < 20 ) {
 		m_selectionBandIsShown = false;
 		return;
 	}
 	bool retransformPlot = true;
 
 	//determine the new plot ranges
 	QPointF logicalZoomStart = cSystem->mapSceneToLogical(m_selectionStart, AbstractCoordinateSystem::SuppressPageClipping);
 	QPointF logicalZoomEnd = cSystem->mapSceneToLogical(m_selectionEnd, AbstractCoordinateSystem::SuppressPageClipping);
 	if (m_selectionEnd.x() > m_selectionStart.x()) {
 		xMin = logicalZoomStart.x();
 		xMax = logicalZoomEnd.x();
 	} else {
 		xMin = logicalZoomEnd.x();
 		xMax = logicalZoomStart.x();
 	}
 
 	if (m_selectionEnd.y() > m_selectionStart.y()) {
 		yMin = logicalZoomEnd.y();
 		yMax = logicalZoomStart.y();
 	} else {
 		yMin = logicalZoomStart.y();
 		yMax = logicalZoomEnd.y();
 	}
 
 	if (mouseMode == CartesianPlot::ZoomSelectionMode) {
 		curvesXMinMaxIsDirty = true;
 		curvesYMinMaxIsDirty = true;
 		q->setAutoScaleX(false);
 		q->setAutoScaleY(false);
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode) {
 		curvesYMinMaxIsDirty = true;
 		q->setAutoScaleX(false);
 		if (q->autoScaleY() && q->scaleAutoY())
 			retransformPlot = false;
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode) {
 		curvesXMinMaxIsDirty = true;
 		q->setAutoScaleY(false);
 		if (q->autoScaleX() && q->scaleAutoX())
 			retransformPlot = false;
 	}
 
 	if (retransformPlot)
 		retransformScales();
 
 	m_selectionBandIsShown = false;
 }
 
 void CartesianPlotPrivate::wheelEvent(QGraphicsSceneWheelEvent* event) {
 	if (locked)
 		return;
 
 	//determine first, which axes are selected and zoom only in the corresponding direction.
 	//zoom the entire plot if no axes selected.
 	bool zoomX = false;
 	bool zoomY = false;
 	for (auto* axis : q->children<Axis>()) {
 		if (!axis->graphicsItem()->isSelected())
 			continue;
 
 		if (axis->orientation() == Axis::AxisHorizontal)
 			zoomX  = true;
 		else
 			zoomY = true;
 	}
 
 	if (event->delta() > 0) {
 		if (!zoomX && !zoomY) {
 			//no special axis selected -> zoom in everything
 			q->zoomIn();
 		} else {
 			if (zoomX) q->zoomInX();
 			if (zoomY) q->zoomInY();
 		}
 	} else {
 		if (!zoomX && !zoomY) {
 			//no special axis selected -> zoom in everything
 			q->zoomOut();
 		} else {
 			if (zoomX) q->zoomOutX();
 			if (zoomY) q->zoomOutY();
 		}
 	}
 }
 
 void CartesianPlotPrivate::keyPressEvent(QKeyEvent * event) {
 	if (event->key() == Qt::Key_Escape) {
 		setCursor(Qt::ArrowCursor);
 		q->setMouseMode(CartesianPlot::MouseMode::SelectionMode);
 		m_selectionBandIsShown = false;
 	}
 	QGraphicsItem::keyPressEvent(event);
 }
 
 void CartesianPlotPrivate::hoverMoveEvent(QGraphicsSceneHoverEvent* event) {
 	QPointF point = event->pos();
 	QString info;
 	if (dataRect.contains(point)) {
 		QPointF logicalPoint = cSystem->mapSceneToLogical(point);
 
 		if ((mouseMode == CartesianPlot::ZoomSelectionMode) ||
 			mouseMode == CartesianPlot::SelectionMode) {
 			info = "x=";
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 
 			info += ", y=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.y());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.y()).toString(yRangeDateTimeFormat);
 		}
 
 		if (mouseMode == CartesianPlot::ZoomSelectionMode && !m_selectionBandIsShown) {
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
 		} else if (mouseMode == CartesianPlot::ZoomXSelectionMode && !m_selectionBandIsShown) {
 			info = "x=";
 			if (xRangeFormat == CartesianPlot::Numeric)
 				 info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
 		} else if (mouseMode == CartesianPlot::ZoomYSelectionMode && !m_selectionBandIsShown) {
 			info = "y=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.y());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.y()).toString(yRangeDateTimeFormat);
 			emit q->mouseHoverZoomSelectionModeSignal(logicalPoint);
 		} else if (mouseMode == CartesianPlot::MouseMode::SelectionMode) {
 			// hover the nearest curve to the mousepointer
 			// hovering curves is implemented in the parent, because no ignoreEvent() exists
 			// for it. Checking all curves and hover the first
 			bool curve_hovered = false;
 			QVector<XYCurve*> curves = q->children<XYCurve>();
 			for (int i=curves.count() - 1; i >= 0; i--){ // because the last curve is above the other curves
 				if (curve_hovered){ // if a curve is already hovered, disable hover for the rest
 					curves[i]->setHover(false);
 					continue;
 				}
 				if (curves[i]->activateCurve(event->pos())){
 					curves[i]->setHover(true);
 					curve_hovered = true;
 					continue;
 				}
 				curves[i]->setHover(false);
 			}
 		} else if (mouseMode == CartesianPlot::Cursor){
 			info = "x=";
 			if (yRangeFormat == CartesianPlot::Numeric)
 				info += QString::number(logicalPoint.x());
 			else
 				info += QDateTime::fromMSecsSinceEpoch(logicalPoint.x()).toString(xRangeDateTimeFormat);
 
 			double cursorPenWidth2 = cursorPen.width()/2.;
 			if (cursorPenWidth2 < 10.)
 				cursorPenWidth2 = 10.;
 			if ((cursor0Enable && qAbs(point.x()-cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMin)).x()) < cursorPenWidth2) ||
 					(cursor1Enable && qAbs(point.x()-cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMin)).x()) < cursorPenWidth2))
 				setCursor(Qt::SizeHorCursor);
 			else
 				setCursor(Qt::ArrowCursor);
 
 			update();
 		}
 	} else
 		emit q->mouseHoverOutsideDataRectSignal();
 
 	q->info(info);
 
 	QGraphicsItem::hoverMoveEvent(event);
 }
 
 void CartesianPlotPrivate::mouseHoverOutsideDataRect() {
 	m_insideDataRect = false;
 	update();
 }
 
 void CartesianPlotPrivate::hoverLeaveEvent(QGraphicsSceneHoverEvent* event) {
 	QVector<XYCurve*> curves = q->children<XYCurve>();
 	for (auto* curve : curves)
 		curve->setHover(false);
 
 	m_hovered = false;
 	QGraphicsItem::hoverLeaveEvent(event);
 }
 
 void CartesianPlotPrivate::mouseHoverZoomSelectionMode(QPointF logicPos) {
 
 	m_insideDataRect = true;
 
 	if (mouseMode == CartesianPlot::ZoomSelectionMode && !m_selectionBandIsShown) {
 
 	} else if (mouseMode == CartesianPlot::ZoomXSelectionMode && !m_selectionBandIsShown) {
 		QPointF p1(logicPos.x(), yMin);
 		QPointF p2(logicPos.x(), yMax);
 		m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1, CartesianCoordinateSystem::MappingFlag::Limit));
 		m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2, CartesianCoordinateSystem::MappingFlag::Limit));
 	} else if (mouseMode == CartesianPlot::ZoomYSelectionMode && !m_selectionBandIsShown) {
 		QPointF p1(xMin, logicPos.y());
 		QPointF p2(xMax, logicPos.y());
 		m_selectionStartLine.setP1(cSystem->mapLogicalToScene(p1, CartesianCoordinateSystem::MappingFlag::Limit));
 		m_selectionStartLine.setP2(cSystem->mapLogicalToScene(p2, CartesianCoordinateSystem::MappingFlag::Limit));
 	}
 	update(); // because if previous another selection mode was selected, the lines must be deleted
 }
 
 void CartesianPlotPrivate::paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget) {
 	Q_UNUSED(option)
 	Q_UNUSED(widget)
 
 	if (!isVisible())
 		return;
 
 	if (!m_printing) {
 		painter->save();
 
 		painter->setPen(cursorPen);
 		QFont font = painter->font();
 		font.setPointSize(font.pointSize() * 4);
 		painter->setFont(font);
 
 		QPointF p1 = cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMin));
 		if (cursor0Enable && p1 != QPointF(0,0)){
 			QPointF p2 = cSystem->mapLogicalToScene(QPointF(cursor0Pos.x(),yMax));
 			painter->drawLine(p1,p2);
 			QPointF textPos = p2;
 			textPos.setX(p2.x() - m_cursor0Text.size().width()/2);
 			textPos.setY(p2.y() - m_cursor0Text.size().height());
 			if (textPos.y() < boundingRect().y())
 				textPos.setY(boundingRect().y());
 			painter->drawStaticText(textPos, m_cursor0Text);
 		}
 
 		p1 = cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMin));
 		if (cursor1Enable && p1 != QPointF(0,0)){
 			QPointF p2 = cSystem->mapLogicalToScene(QPointF(cursor1Pos.x(),yMax));
 			painter->drawLine(p1,p2);
 			QPointF textPos = p2;
 			// TODO: Moving this stuff into other function to not calculate it every time
 			textPos.setX(p2.x() - m_cursor1Text.size().width()/2);
 			textPos.setY(p2.y() - m_cursor1Text.size().height());
 			if (textPos.y() < boundingRect().y())
 				textPos.setY(boundingRect().y());
 			painter->drawStaticText(textPos, m_cursor1Text);
 		}
 
 		painter->restore();
 	}
 
 	painter->setPen(QPen(Qt::black, 3));
 	if ((mouseMode == CartesianPlot::ZoomXSelectionMode || mouseMode == CartesianPlot::ZoomYSelectionMode)
 			&& (!m_selectionBandIsShown) && m_insideDataRect)
 		painter->drawLine(m_selectionStartLine);
 
 	if (m_selectionBandIsShown) {
 		QPointF selectionStart = m_selectionStart;
 		if (m_selectionStart.x() > dataRect.right())
 			selectionStart.setX(dataRect.right());
 		if (m_selectionStart.x() < dataRect.left())
 			selectionStart.setX(dataRect.left());
 		if (m_selectionStart.y() > dataRect.bottom())
 			selectionStart.setY(dataRect.bottom());
 		if (m_selectionStart.y() < dataRect.top())
 			selectionStart.setY(dataRect.top());
 
 		QPointF selectionEnd = m_selectionEnd;
 		if (m_selectionEnd.x() > dataRect.right())
 			selectionEnd.setX(dataRect.right());
 		if (m_selectionEnd.x() < dataRect.left())
 			selectionEnd.setX(dataRect.left());
 		if (m_selectionEnd.y() > dataRect.bottom())
 			selectionEnd.setY(dataRect.bottom());
 		if (m_selectionEnd.y() < dataRect.top())
 			selectionEnd.setY(dataRect.top());
 		painter->save();
 		painter->setPen(QPen(Qt::black, 5));
 		painter->drawRect(QRectF(selectionStart, selectionEnd));
 		painter->setBrush(Qt::blue);
 		painter->setOpacity(0.2);
 		painter->drawRect(QRectF(selectionStart, selectionEnd));
 		painter->restore();
 	}
 }
 
 //##############################################################################
 //##################  Serialization/Deserialization  ###########################
 //##############################################################################
 
 //! Save as XML
 void CartesianPlot::save(QXmlStreamWriter* writer) const {
 	Q_D(const CartesianPlot);
 
 	writer->writeStartElement( "cartesianPlot" );
 	writeBasicAttributes(writer);
 	writeCommentElement(writer);
 
 	//applied theme
 	if (!d->theme.isEmpty()) {
 		writer->writeStartElement( "theme" );
 		writer->writeAttribute("name", d->theme);
 		writer->writeEndElement();
 	}
 
 	//cursor
 	writer->writeStartElement( "cursor" );
 	WRITE_QPEN(d->cursorPen);
 	writer->writeEndElement();
 	//geometry
 	writer->writeStartElement( "geometry" );
 	writer->writeAttribute( "x", QString::number(d->rect.x()) );
 	writer->writeAttribute( "y", QString::number(d->rect.y()) );
 	writer->writeAttribute( "width", QString::number(d->rect.width()) );
 	writer->writeAttribute( "height", QString::number(d->rect.height()) );
 	writer->writeAttribute( "visible", QString::number(d->isVisible()) );
 	writer->writeEndElement();
 
 	//coordinate system and padding
 	writer->writeStartElement( "coordinateSystem" );
 	writer->writeAttribute( "autoScaleX", QString::number(d->autoScaleX) );
 	writer->writeAttribute( "autoScaleY", QString::number(d->autoScaleY) );
 	writer->writeAttribute( "xMin", QString::number(d->xMin, 'g', 16));
 	writer->writeAttribute( "xMax", QString::number(d->xMax, 'g', 16) );
 	writer->writeAttribute( "yMin", QString::number(d->yMin, 'g', 16) );
 	writer->writeAttribute( "yMax", QString::number(d->yMax, 'g', 16) );
 	writer->writeAttribute( "xScale", QString::number(d->xScale) );
 	writer->writeAttribute( "yScale", QString::number(d->yScale) );
 	writer->writeAttribute( "xRangeFormat", QString::number(d->xRangeFormat) );
 	writer->writeAttribute( "yRangeFormat", QString::number(d->yRangeFormat) );
 	writer->writeAttribute( "horizontalPadding", QString::number(d->horizontalPadding) );
 	writer->writeAttribute( "verticalPadding", QString::number(d->verticalPadding) );
 	writer->writeAttribute( "rightPadding", QString::number(d->rightPadding) );
 	writer->writeAttribute( "bottomPadding", QString::number(d->bottomPadding) );
 	writer->writeAttribute( "symmetricPadding", QString::number(d->symmetricPadding));
 	writer->writeEndElement();
 
 	//x-scale breaks
 	if (d->xRangeBreakingEnabled || !d->xRangeBreaks.list.isEmpty()) {
 		writer->writeStartElement("xRangeBreaks");
 		writer->writeAttribute( "enabled", QString::number(d->xRangeBreakingEnabled) );
 		for (const auto& rb : d->xRangeBreaks.list) {
 			writer->writeStartElement("xRangeBreak");
 			writer->writeAttribute("start", QString::number(rb.start));
 			writer->writeAttribute("end", QString::number(rb.end));
 			writer->writeAttribute("position", QString::number(rb.position));
 			writer->writeAttribute("style", QString::number(rb.style));
 			writer->writeEndElement();
 		}
 		writer->writeEndElement();
 	}
 
 	//y-scale breaks
 	if (d->yRangeBreakingEnabled || !d->yRangeBreaks.list.isEmpty()) {
 		writer->writeStartElement("yRangeBreaks");
 		writer->writeAttribute( "enabled", QString::number(d->yRangeBreakingEnabled) );
 		for (const auto& rb : d->yRangeBreaks.list) {
 			writer->writeStartElement("yRangeBreak");
 			writer->writeAttribute("start", QString::number(rb.start));
 			writer->writeAttribute("end", QString::number(rb.end));
 			writer->writeAttribute("position", QString::number(rb.position));
 			writer->writeAttribute("style", QString::number(rb.style));
 			writer->writeEndElement();
 		}
 		writer->writeEndElement();
 	}
 
 	//serialize all children (plot area, title text label, axes and curves)
 	for (auto* elem : children<WorksheetElement>(IncludeHidden))
 		elem->save(writer);
 
 	writer->writeEndElement(); // close "cartesianPlot" section
 }
 
 
 //! Load from XML
 bool CartesianPlot::load(XmlStreamReader* reader, bool preview) {
 	Q_D(CartesianPlot);
 
 	if (!readBasicAttributes(reader))
 		return false;
 
 	KLocalizedString attributeWarning = ki18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs;
 	QString str;
 	bool titleLabelRead = false;
 
 	while (!reader->atEnd()) {
 		reader->readNext();
 		if (reader->isEndElement() && reader->name() == "cartesianPlot")
 			break;
 
 		if (!reader->isStartElement())
 			continue;
 
 		if (reader->name() == "comment") {
 			if (!readCommentElement(reader))
 				return false;
 		} else if (!preview && reader->name() == "theme") {
 			attribs = reader->attributes();
 			d->theme = attribs.value("name").toString();
 		} else if (!preview && reader->name() == "cursor") {
 			attribs = reader->attributes();
 			QPen pen;
 			pen.setWidth(attribs.value("width").toInt());
 			pen.setStyle(static_cast<Qt::PenStyle>(attribs.value("style").toInt()));
 			QColor color;
 			color.setRed(attribs.value("color_r").toInt());
 			color.setGreen(attribs.value("color_g").toInt());
 			color.setBlue(attribs.value("color_b").toInt());
 			pen.setColor(color);
 			d->cursorPen = pen;
 		} else if (!preview && reader->name() == "geometry") {
 			attribs = reader->attributes();
 
 			str = attribs.value("x").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("x").toString());
 			else
 				d->rect.setX( str.toDouble() );
 
 			str = attribs.value("y").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("y").toString());
 			else
 				d->rect.setY( str.toDouble() );
 
 			str = attribs.value("width").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("width").toString());
 			else
 				d->rect.setWidth( str.toDouble() );
 
 			str = attribs.value("height").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("height").toString());
 			else
 				d->rect.setHeight( str.toDouble() );
 
 			str = attribs.value("visible").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("visible").toString());
 			else
 				d->setVisible(str.toInt());
 		} else if (!preview && reader->name() == "coordinateSystem") {
 			attribs = reader->attributes();
 
 			READ_INT_VALUE("autoScaleX", autoScaleX, bool);
 			READ_INT_VALUE("autoScaleY", autoScaleY, bool);
 
 			str = attribs.value("xMin").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("xMin").toString());
 			else {
 				d->xMin = str.toDouble();
 				d->xMinPrev = d->xMin;
 			}
 
 			str = attribs.value("xMax").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("xMax").toString());
 			else {
 				d->xMax = str.toDouble();
 				d->xMaxPrev = d->xMax;
 			}
 
 			str = attribs.value("yMin").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("yMin").toString());
 			else {
 				d->yMin = str.toDouble();
 				d->yMinPrev = d->yMin;
 			}
 
 			str = attribs.value("yMax").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("yMax").toString());
 			else {
 				d->yMax = str.toDouble();
 				d->yMaxPrev = d->yMax;
 			}
 
 			READ_INT_VALUE("xScale", xScale, CartesianPlot::Scale);
 			READ_INT_VALUE("yScale", yScale, CartesianPlot::Scale);
 
 			READ_INT_VALUE("xRangeFormat", xRangeFormat, CartesianPlot::RangeFormat);
 			READ_INT_VALUE("yRangeFormat", yRangeFormat, CartesianPlot::RangeFormat);
 
 			READ_DOUBLE_VALUE("horizontalPadding", horizontalPadding);
 			READ_DOUBLE_VALUE("verticalPadding", verticalPadding);
 			READ_DOUBLE_VALUE("rightPadding", rightPadding);
 			READ_DOUBLE_VALUE("bottomPadding", bottomPadding);
 			READ_INT_VALUE("symmetricPadding", symmetricPadding, bool);
 		} else if (!preview && reader->name() == "xRangeBreaks") {
 			//delete default rang break
 			d->xRangeBreaks.list.clear();
 
 			attribs = reader->attributes();
 			READ_INT_VALUE("enabled", xRangeBreakingEnabled, bool);
 		} else if (!preview && reader->name() == "xRangeBreak") {
 			attribs = reader->attributes();
 
 			RangeBreak b;
 			str = attribs.value("start").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("start").toString());
 			else
 				b.start = str.toDouble();
 
 			str = attribs.value("end").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("end").toString());
 			else
 				b.end = str.toDouble();
 
 			str = attribs.value("position").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("position").toString());
 			else
 				b.position = str.toDouble();
 
 			str = attribs.value("style").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("style").toString());
 			else
 				b.style = CartesianPlot::RangeBreakStyle(str.toInt());
 
 			d->xRangeBreaks.list << b;
 		} else if (!preview && reader->name() == "yRangeBreaks") {
 			//delete default rang break
 			d->yRangeBreaks.list.clear();
 
 			attribs = reader->attributes();
 			READ_INT_VALUE("enabled", yRangeBreakingEnabled, bool);
 		} else if (!preview && reader->name() == "yRangeBreak") {
 			attribs = reader->attributes();
 
 			RangeBreak b;
 			str = attribs.value("start").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("start").toString());
 			else
 				b.start = str.toDouble();
 
 			str = attribs.value("end").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("end").toString());
 			else
 				b.end = str.toDouble();
 
 			str = attribs.value("position").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("position").toString());
 			else
 				b.position = str.toDouble();
 
 			str = attribs.value("style").toString();
 			if (str.isEmpty())
 				reader->raiseWarning(attributeWarning.subs("style").toString());
 			else
 				b.style = CartesianPlot::RangeBreakStyle(str.toInt());
 
 			d->yRangeBreaks.list << b;
 		} else if (reader->name() == "textLabel") {
 			if (!titleLabelRead) {
 				//the first text label is always the title label
 				m_title->load(reader, preview);
 				titleLabelRead = true;
 
 				//TODO: the name is read in m_title->load() but we overwrite it here
 				//since the old projects don't have this " - Title" appendix yet that we add in init().
 				//can be removed in couple of releases
 				m_title->setName(name() + QLatin1String(" - ") + i18n("Title"));
 			} else {
 				TextLabel* label = new TextLabel("text label");
 				if (label->load(reader, preview)) {
 					addChildFast(label);
 					label->setParentGraphicsItem(graphicsItem());
 				} else {
 					delete label;
 					return false;
 				}
 			}
+		} else if (reader->name() == "image") {
+			Image* image = new Image(QString());
+			if (!image->load(reader, preview)) {
+				delete image;
+				return false;
+			} else
+				addChildFast(image);
 		} else if (reader->name() == "plotArea")
 			m_plotArea->load(reader, preview);
 		else if (reader->name() == "axis") {
 			Axis* axis = new Axis(QString());
 			if (axis->load(reader, preview))
 				addChildFast(axis);
 			else {
 				delete axis;
 				return false;
 			}
 		} else if (reader->name() == "xyCurve") {
 			XYCurve* curve = new XYCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyEquationCurve") {
 			XYEquationCurve* curve = new XYEquationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDataReductionCurve") {
 			XYDataReductionCurve* curve = new XYDataReductionCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyDifferentiationCurve") {
 			XYDifferentiationCurve* curve = new XYDifferentiationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyIntegrationCurve") {
 			XYIntegrationCurve* curve = new XYIntegrationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyInterpolationCurve") {
 			XYInterpolationCurve* curve = new XYInterpolationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xySmoothCurve") {
 			XYSmoothCurve* curve = new XYSmoothCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFitCurve") {
 			XYFitCurve* curve = new XYFitCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierFilterCurve") {
 			XYFourierFilterCurve* curve = new XYFourierFilterCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyFourierTransformCurve") {
 			XYFourierTransformCurve* curve = new XYFourierTransformCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyConvolutionCurve") {
 			XYConvolutionCurve* curve = new XYConvolutionCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "xyCorrelationCurve") {
 			XYCorrelationCurve* curve = new XYCorrelationCurve(QString());
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else if (reader->name() == "cartesianPlotLegend") {
 			m_legend = new CartesianPlotLegend(this, QString());
 			if (m_legend->load(reader, preview))
 				addChildFast(m_legend);
 			else {
 				delete m_legend;
 				return false;
 			}
 		} else if (reader->name() == "customPoint") {
 			CustomPoint* point = new CustomPoint(this, QString());
 			if (point->load(reader, preview))
 				addChildFast(point);
 			else {
 				delete point;
 				return false;
 			}
 		} else if (reader->name() == "Histogram") {
 			Histogram* curve = new Histogram("Histogram");
 			if (curve->load(reader, preview))
 				addChildFast(curve);
 			else {
 				removeChild(curve);
 				return false;
 			}
 		} else { // unknown element
 			reader->raiseWarning(i18n("unknown cartesianPlot element '%1'", reader->name().toString()));
 			if (!reader->skipToEndElement()) return false;
 		}
 	}
 
 	if (preview)
 		return true;
 
 	d->retransform();
 
 	//if a theme was used, initialize the color palette
 	if (!d->theme.isEmpty()) {
 		//TODO: check whether the theme config really exists
 		KConfig config( ThemeHandler::themeFilePath(d->theme), KConfig::SimpleConfig );
 		this->setColorPalette(config);
 	} else {
 		//initialize the color palette with default colors
 		this->setColorPalette(KConfig());
 	}
 
 	return true;
 }
 
 //##############################################################################
 //#########################  Theme management ##################################
 //##############################################################################
 void CartesianPlot::loadTheme(const QString& theme) {
 	KConfig config(ThemeHandler::themeFilePath(theme), KConfig::SimpleConfig);
 	loadThemeConfig(config);
 }
 
 void CartesianPlot::loadThemeConfig(const KConfig& config) {
 	QString str = config.name();
 
 	// theme path is saved with UNIX dir separator
 	str = str.right(str.length() - str.lastIndexOf(QLatin1Char('/')) - 1);
 	DEBUG("	set theme to " << str.toStdString());
 	this->setTheme(str);
 
 	//load the color palettes for the curves
 	this->setColorPalette(config);
 
 	//load the theme for all the children
 	for (auto* child : children<WorksheetElement>(AbstractAspect::IncludeHidden))
 		child->loadThemeConfig(config);
 
 	Q_D(CartesianPlot);
 	d->update(this->rect());
 }
 
 void CartesianPlot::saveTheme(KConfig &config) {
 	const QVector<Axis*>& axisElements = children<Axis>(AbstractAspect::IncludeHidden);
 	const QVector<PlotArea*>& plotAreaElements = children<PlotArea>(AbstractAspect::IncludeHidden);
 	const QVector<TextLabel*>& textLabelElements = children<TextLabel>(AbstractAspect::IncludeHidden);
 
 	axisElements.at(0)->saveThemeConfig(config);
 	plotAreaElements.at(0)->saveThemeConfig(config);
 	textLabelElements.at(0)->saveThemeConfig(config);
 
 	for (auto *child : children<XYCurve>(AbstractAspect::IncludeHidden))
 		child->saveThemeConfig(config);
 }
 
 //Generating colors from 5-color theme palette
 void CartesianPlot::setColorPalette(const KConfig& config) {
 	if (config.hasGroup(QLatin1String("Theme"))) {
 		KConfigGroup group = config.group(QLatin1String("Theme"));
 
 		//read the five colors defining the palette
 		m_themeColorPalette.clear();
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor1", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor2", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor3", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor4", QColor()));
 		m_themeColorPalette.append(group.readEntry("ThemePaletteColor5", QColor()));
 	} else {
 		//no theme is available, provide 5 "default colors"
 		m_themeColorPalette.clear();
 		m_themeColorPalette.append(QColor(25, 25, 25));
 		m_themeColorPalette.append(QColor(0, 0, 127));
 		m_themeColorPalette.append(QColor(127 ,0, 0));
 		m_themeColorPalette.append(QColor(0, 127, 0));
 		m_themeColorPalette.append(QColor(85, 0, 127));
 	}
 
 	//generate 30 additional shades if the color palette contains more than one color
 	if (m_themeColorPalette.at(0) != m_themeColorPalette.at(1)) {
 		QColor c;
 
 		//3 factors to create shades from theme's palette
 		std::array<float, 3> fac = {0.25f, 0.45f, 0.65f};
 
 		//Generate 15 lighter shades
 		for (int i = 0; i < 5; i++) {
 			for (int j = 1; j < 4; j++) {
 				c.setRed( m_themeColorPalette.at(i).red()*(1-fac[j-1]) );
 				c.setGreen( m_themeColorPalette.at(i).green()*(1-fac[j-1]) );
 				c.setBlue( m_themeColorPalette.at(i).blue()*(1-fac[j-1]) );
 				m_themeColorPalette.append(c);
 			}
 		}
 
 		//Generate 15 darker shades
 		for (int i = 0; i < 5; i++) {
 			for (int j = 4; j < 7; j++) {
 				c.setRed( m_themeColorPalette.at(i).red()+((255-m_themeColorPalette.at(i).red())*fac[j-4]) );
 				c.setGreen( m_themeColorPalette.at(i).green()+((255-m_themeColorPalette.at(i).green())*fac[j-4]) );
 				c.setBlue( m_themeColorPalette.at(i).blue()+((255-m_themeColorPalette.at(i).blue())*fac[j-4]) );
 				m_themeColorPalette.append(c);
 			}
 		}
 	}
 }
 
 const QList<QColor>& CartesianPlot::themeColorPalette() const {
 	return m_themeColorPalette;
 }
diff --git a/src/backend/worksheet/plots/cartesian/CartesianPlot.h b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
index f386d5ff7..d7937fc5b 100644
--- a/src/backend/worksheet/plots/cartesian/CartesianPlot.h
+++ b/src/backend/worksheet/plots/cartesian/CartesianPlot.h
@@ -1,332 +1,334 @@
 
 /***************************************************************************
     File                 : CartesianPlot.h
     Project              : LabPlot
     Description          : Cartesian plot
     --------------------------------------------------------------------
     Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2018 by Stefan Gerlach (stefan.gerlach@uni.kn)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef CARTESIANPLOT_H
 #define CARTESIANPLOT_H
 
 #include "backend/worksheet/plots/AbstractPlot.h"
 #include "backend/worksheet/plots/cartesian/Histogram.h"
 
 #include <cmath>
 
 class QDropEvent;
 class QToolBar;
 class CartesianPlotPrivate;
 class CartesianPlotLegend;
 class AbstractColumn;
 class XYCurve;
 class XYEquationCurve;
 class XYDataReductionCurve;
 class XYDifferentiationCurve;
 class XYIntegrationCurve;
 class XYInterpolationCurve;
 class XYSmoothCurve;
 class XYFitCurve;
 class XYFourierFilterCurve;
 class XYFourierTransformCurve;
 class XYConvolutionCurve;
 class XYCorrelationCurve;
 class KConfig;
 
 class CartesianPlot : public AbstractPlot {
 	Q_OBJECT
 
 public:
 	explicit CartesianPlot(const QString &name);
 	~CartesianPlot() override;
 
 	enum Scale {ScaleLinear, ScaleLog10, ScaleLog2, ScaleLn, ScaleLog10Abs, ScaleLog2Abs, ScaleLnAbs, ScaleSqrt, ScaleX2};
 	enum Type {FourAxes, TwoAxes, TwoAxesCentered, TwoAxesCenteredZero};
 	enum RangeFormat {Numeric, DateTime};
 	enum RangeType {RangeFree, RangeLast, RangeFirst};
 	enum RangeBreakStyle {RangeBreakSimple, RangeBreakVertical, RangeBreakSloped};
 	enum MouseMode {SelectionMode, ZoomSelectionMode, ZoomXSelectionMode, ZoomYSelectionMode, Cursor};
 	enum NavigationOperation {ScaleAuto, ScaleAutoX, ScaleAutoY, ZoomIn, ZoomOut, ZoomInX, ZoomOutX,
 	                          ZoomInY, ZoomOutY, ShiftLeftX, ShiftRightX, ShiftUpY, ShiftDownY
 	                         };
 
 	struct RangeBreak {
 		RangeBreak() : start(NAN), end(NAN), position(0.5), style(RangeBreakSloped) {}
 		bool isValid() const {
 			return (!std::isnan(start) && !std::isnan(end));
 		}
 		double start;
 		double end;
 		double position;
 		RangeBreakStyle style;
 	};
 
 	//simple wrapper for QList<RangeBreaking> in order to get our macros working
 	struct RangeBreaks {
 		RangeBreaks() : lastChanged(-1) {
 			RangeBreak b;
 			list << b;
 		};
 		QList<RangeBreak> list;
 		int lastChanged;
 	};
 
 	void initDefault(Type = FourAxes);
 	QIcon icon() const override;
 	QMenu* createContextMenu() override;
 	QMenu* analysisMenu();
 	QVector<AbstractAspect*> dependsOn() const override;
 	void setRect(const QRectF&) override;
 	QRectF dataRect() const;
 	void setMouseMode(const MouseMode);
 	void setLocked(const bool);
 	MouseMode mouseMode() const;
 	void navigate(NavigationOperation);
 	void setSuppressDataChangedSignal(bool);
 	const QList<QColor>& themeColorPalette() const;
 	void processDropEvent(QDropEvent*) override;
 	bool isPanningActive() const;
 	bool isHovered() const;
 	bool isPrinted() const;
 	bool isSelected() const;
 	void addLegend(CartesianPlotLegend*);
 	int curveCount();
 	const XYCurve* getCurve(int index);
 	double cursorPos(int cursorNumber);
 
 	void save(QXmlStreamWriter*) const override;
 	bool load(XmlStreamReader*, bool preview) override;
 	void loadThemeConfig(const KConfig&) override;
 	void saveTheme(KConfig& config);
 	void mousePressZoomSelectionMode(QPointF logicPos);
 	void mousePressCursorMode(int cursorNumber, QPointF logicPos);
 	void mouseMoveZoomSelectionMode(QPointF logicPos);
 	void mouseMoveCursorMode(int cursorNumber, QPointF logicPos);
 	void mouseReleaseZoomSelectionMode();
 	void mouseHoverZoomSelectionMode(QPointF logicPos);
 	void mouseHoverOutsideDataRect();
 
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeFormat, xRangeFormat, XRangeFormat)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeFormat, yRangeFormat, YRangeFormat)
 	const QString& xRangeDateTimeFormat() const;
 	const QString& yRangeDateTimeFormat() const;
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::RangeType, rangeType, RangeType)
 	BASIC_D_ACCESSOR_DECL(int, rangeLastValues, RangeLastValues)
 	BASIC_D_ACCESSOR_DECL(int, rangeFirstValues, RangeFirstValues)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleX, AutoScaleX)
 	BASIC_D_ACCESSOR_DECL(bool, autoScaleY, AutoScaleY)
 	BASIC_D_ACCESSOR_DECL(double, xMin, XMin)
 	BASIC_D_ACCESSOR_DECL(double, xMax, XMax)
 	BASIC_D_ACCESSOR_DECL(double, yMin, YMin)
 	BASIC_D_ACCESSOR_DECL(double, yMax, YMax)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, xScale, XScale)
 	BASIC_D_ACCESSOR_DECL(CartesianPlot::Scale, yScale, YScale)
 	BASIC_D_ACCESSOR_DECL(bool, xRangeBreakingEnabled, XRangeBreakingEnabled)
 	BASIC_D_ACCESSOR_DECL(bool, yRangeBreakingEnabled, YRangeBreakingEnabled)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, xRangeBreaks, XRangeBreaks)
 	CLASS_D_ACCESSOR_DECL(RangeBreaks, yRangeBreaks, YRangeBreaks)
 	CLASS_D_ACCESSOR_DECL(QPen, cursorPen, CursorPen);
 	CLASS_D_ACCESSOR_DECL(bool, cursor0Enable, Cursor0Enable);
 	CLASS_D_ACCESSOR_DECL(bool, cursor1Enable, Cursor1Enable);
 
 	QString theme() const;
 
 	typedef CartesianPlotPrivate Private;
 
 public slots:
 	void setTheme(const QString&);
 
 private:
 	void init();
 	void initActions();
 	void initMenus();
 	void setColorPalette(const KConfig&);
 	const XYCurve* currentCurve() const;
 
 	void calculateCurvesXMinMax(bool completeRange = true);
 	void calculateCurvesYMinMax(bool completeRange = true);
 
 	CartesianPlotLegend* m_legend{nullptr};
 	double m_zoomFactor{1.2};
 	QList<QColor> m_themeColorPalette;
 	bool m_menusInitialized{false};
 
 	QAction* visibilityAction;
 
 	//"add new" actions
 	QAction* addCurveAction;
 	QAction* addEquationCurveAction;
 	QAction* addHistogramAction;
 	QAction* addDataReductionCurveAction;
 	QAction* addDifferentiationCurveAction;
 	QAction* addIntegrationCurveAction;
 	QAction* addInterpolationCurveAction;
 	QAction* addSmoothCurveAction;
 	QAction* addFitCurveAction;
 	QAction* addFourierFilterCurveAction;
 	QAction* addFourierTransformCurveAction;
 	QAction* addConvolutionCurveAction;
 	QAction* addCorrelationCurveAction;
 
 	QAction* addHorizontalAxisAction;
 	QAction* addVerticalAxisAction;
 	QAction* addLegendAction;
 	QAction* addTextLabelAction;
+	QAction* addImageAction;
 	QAction* addCustomPointAction;
 
 	//scaling, zooming, navigation actions
 	QAction* scaleAutoXAction;
 	QAction* scaleAutoYAction;
 	QAction* scaleAutoAction;
 	QAction* zoomInAction;
 	QAction* zoomOutAction;
 	QAction* zoomInXAction;
 	QAction* zoomOutXAction;
 	QAction* zoomInYAction;
 	QAction* zoomOutYAction;
 	QAction* shiftLeftXAction;
 	QAction* shiftRightXAction;
 	QAction* shiftUpYAction;
 	QAction* shiftDownYAction;
 
 	//analysis menu actions
 	QAction* addDataOperationAction;
 	QAction* addDataReductionAction;
 	QAction* addDifferentiationAction;
 	QAction* addIntegrationAction;
 	QAction* addInterpolationAction;
 	QAction* addSmoothAction;
 	QVector <QAction*> addFitAction;
 	QAction* addFourierFilterAction;
 	QAction* addFourierTransformAction;
 	QAction* addConvolutionAction;
 	QAction* addCorrelationAction;
 
 	QMenu* addNewMenu{nullptr};
 	QMenu* addNewAnalysisMenu{nullptr};
 	QMenu* zoomMenu{nullptr};
 	QMenu* dataAnalysisMenu{nullptr};
 	QMenu* themeMenu{nullptr};
 
 	Q_DECLARE_PRIVATE(CartesianPlot)
 
 public slots:
 	void addHorizontalAxis();
 	void addVerticalAxis();
 	void addCurve();
 	void addHistogram();
 	void addEquationCurve();
 	void addDataReductionCurve();
 	void addDifferentiationCurve();
 	void addIntegrationCurve();
 	void addInterpolationCurve();
 	void addSmoothCurve();
 	void addFitCurve();
 	void addFourierFilterCurve();
 	void addFourierTransformCurve();
 	void addConvolutionCurve();
 	void addCorrelationCurve();
 
 	void addLegend();
 	void addTextLabel();
+	void addImage();
 	void addCustomPoint();
 	void scaleAutoTriggered();
 	bool scaleAuto();
 	bool scaleAutoX();
 	bool scaleAutoY();
 	void zoomIn();
 	void zoomOut();
 	void zoomInX();
 	void zoomOutX();
 	void zoomInY();
 	void zoomOutY();
 	void shiftLeftX();
 	void shiftRightX();
 	void shiftUpY();
 	void shiftDownY();
 	void cursor();
 	void dataChanged();
 
 	void curveLinePenChanged(QPen);
 
 private slots:
 	void updateLegend();
 	void childAdded(const AbstractAspect*);
 	void childRemoved(const AbstractAspect* parent, const AbstractAspect* before, const AbstractAspect* child);
 	void childHovered();
 
 	void xDataChanged();
 	void yDataChanged();
 	void curveVisibilityChanged();
 
 	//SLOTs for changes triggered via QActions in the context menu
 	void visibilityChanged();
 	void loadTheme(const QString&);
 
 protected:
 	CartesianPlot(const QString &name, CartesianPlotPrivate *dd);
 
 signals:
 	void rangeTypeChanged(CartesianPlot::RangeType);
 	void xRangeFormatChanged(CartesianPlot::RangeFormat);
 	void yRangeFormatChanged(CartesianPlot::RangeFormat);
 	void rangeLastValuesChanged(int);
 	void rangeFirstValuesChanged(int);
 	void rectChanged(QRectF&);
 	void xAutoScaleChanged(bool);
 	void xMinChanged(double);
 	void xMaxChanged(double);
 	void xScaleChanged(int);
 	void yAutoScaleChanged(bool);
 	void yMinChanged(double);
 	void yMaxChanged(double);
 	void yScaleChanged(int);
 	void xRangeBreakingEnabledChanged(bool);
 	void xRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void yRangeBreakingEnabledChanged(bool);
 	void yRangeBreaksChanged(const CartesianPlot::RangeBreaks&);
 	void themeChanged(const QString&);
 	void mousePressZoomSelectionModeSignal(QPointF logicPos);
 	void mousePressCursorModeSignal(int cursorNumber, QPointF logicPos);
 	void mouseMoveZoomSelectionModeSignal(QPointF logicPos);
 	void mouseMoveCursorModeSignal(int cursorNumber, QPointF logicPos);
 	void mouseReleaseCursorModeSignal();
 	void mouseReleaseZoomSelectionModeSignal();
 	void mouseHoverZoomSelectionModeSignal(QPointF logicalPoint);
 	void mouseHoverOutsideDataRectSignal();
 	void curveNameChanged(const AbstractAspect* curve);
 	void cursorPosChanged(int cursorNumber, double xPos);
 	void curveAdded(const XYCurve*);
 	void curveRemoved(const XYCurve*);
 	void curveLinePenChanged(QPen, QString curveName);
 	void cursorPenChanged(QPen);
 	void curveDataChanged(const XYCurve*);
 	void curveVisibilityChangedSignal();
 	void mouseModeChanged(MouseMode);
 	void cursor0EnableChanged(bool enable);
 	void cursor1EnableChanged(bool enable);
 };
 
 #endif
diff --git a/src/commonfrontend/worksheet/WorksheetView.cpp b/src/commonfrontend/worksheet/WorksheetView.cpp
index 0397274d2..e6a96c8e7 100644
--- a/src/commonfrontend/worksheet/WorksheetView.cpp
+++ b/src/commonfrontend/worksheet/WorksheetView.cpp
@@ -1,2022 +1,2027 @@
 /***************************************************************************
     File                 : WorksheetView.cpp
     Project              : LabPlot
     Description          : Worksheet view
     --------------------------------------------------------------------
     Copyright            : (C) 2009-2019 Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2016-2018 Stefan-Gerlach (stefan.gerlach@uni.kn)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 #include "commonfrontend/worksheet/WorksheetView.h"
 #include "backend/core/AbstractColumn.h"
 #include "backend/worksheet/plots/cartesian/Axis.h"
 #include "backend/worksheet/plots/cartesian/XYCurve.h"
 #include "backend/worksheet/plots/cartesian/XYCurvePrivate.h"
 #include "backend/worksheet/Image.h"
 #include "backend/worksheet/TextLabel.h"
 #include "commonfrontend/core/PartMdiView.h"
 #include "kdefrontend/widgets/ThemesWidget.h"
 #include "kdefrontend/worksheet/GridDialog.h"
 #include "kdefrontend/worksheet/PresenterWidget.h"
 #include "kdefrontend/worksheet/DynamicPresenterWidget.h"
 #include "backend/lib/trace.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMdiArea>
 #include <QMenu>
 #include <QToolBar>
 #include <QScreen>
 #include <QWheelEvent>
 #include <QPrinter>
 #include <QSvgGenerator>
 #include <QImage>
 #include <QToolButton>
 #include <QGraphicsOpacityEffect>
 #include <QTimeLine>
 #include <QClipboard>
 #include <QMimeData>
 #include <QWidgetAction>
 
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KConfigGroup>
 
 #ifdef Q_OS_MAC
 #include "3rdparty/kdmactouchbar/src/kdmactouchbar.h"
 #endif
 
 #include <limits>
 
 /**
  * \class WorksheetView
  * \brief Worksheet view
  */
 
 /*!
   Constructur of the class.
   Creates a view for the Worksheet \c worksheet and initializes the internal model.
 */
 WorksheetView::WorksheetView(Worksheet* worksheet) : QGraphicsView(), m_worksheet(worksheet) {
 	setScene(m_worksheet->scene());
 
 	setRenderHint(QPainter::Antialiasing);
 	setRubberBandSelectionMode(Qt::ContainsItemBoundingRect);
 	setTransformationAnchor(QGraphicsView::AnchorViewCenter);
 	setResizeAnchor(QGraphicsView::AnchorViewCenter);
 	setMinimumSize(16, 16);
 	setFocusPolicy(Qt::StrongFocus);
 
 	if (m_worksheet->useViewSize()) {
 		setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 		setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 	}
 
 	viewport()->setAttribute( Qt::WA_OpaquePaintEvent );
 	viewport()->setAttribute( Qt::WA_NoSystemBackground );
 	setAcceptDrops(true);
 	setCacheMode(QGraphicsView::CacheBackground);
 
 	m_gridSettings.style = WorksheetView::NoGrid;
 
 	//signal/slot connections
 	connect(m_worksheet, &Worksheet::requestProjectContextMenu, this, &WorksheetView::createContextMenu);
 	connect(m_worksheet, &Worksheet::itemSelected, this, &WorksheetView::selectItem);
 	connect(m_worksheet, &Worksheet::itemDeselected, this, &WorksheetView::deselectItem);
 	connect(m_worksheet, &Worksheet::requestUpdate, this, &WorksheetView::updateBackground);
 	connect(m_worksheet, &Worksheet::aspectAboutToBeRemoved, this, &WorksheetView::aspectAboutToBeRemoved);
 	connect(m_worksheet, &Worksheet::useViewSizeRequested, this, &WorksheetView::useViewSizeRequested);
 	connect(m_worksheet, &Worksheet::layoutChanged, this, &WorksheetView::layoutChanged);
 	connect(scene(), &QGraphicsScene::selectionChanged, this, &WorksheetView::selectionChanged);
 
 	//resize the view to make the complete scene visible.
 	//no need to resize the view when the project is being opened,
 	//all views will be resized to the stored values at the end
 	if (!m_worksheet->isLoading()) {
 		float w = Worksheet::convertFromSceneUnits(sceneRect().width(), Worksheet::Inch);
 		float h = Worksheet::convertFromSceneUnits(sceneRect().height(), Worksheet::Inch);
 		w *= QApplication::desktop()->physicalDpiX();
 		h *= QApplication::desktop()->physicalDpiY();
 		resize(w*1.1, h*1.1);
 	}
 
 	//rescale to the original size
 	static const float hscale = QApplication::desktop()->physicalDpiX()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 	static const float vscale = QApplication::desktop()->physicalDpiY()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 	setTransform(QTransform::fromScale(hscale, vscale));
 
 	initBasicActions();
 }
 
 /*!
  * initializes couple of actions that have shortcuts assigned in the constructor as opposed
  * to other actions in initAction() that are create on demand only if the context menu is requested
  */
 void WorksheetView::initBasicActions() {
 	selectAllAction = new QAction(QIcon::fromTheme("edit-select-all"), i18n("Select All"), this);
 	this->addAction(selectAllAction);
 	connect(selectAllAction, &QAction::triggered, this, &WorksheetView::selectAllElements);
 
 	deleteAction = new QAction(QIcon::fromTheme("edit-delete"), i18n("Delete"), this);
 	this->addAction(deleteAction);
 	connect(deleteAction, &QAction::triggered, this, &WorksheetView::deleteElement);
 
 	backspaceAction = new QAction(this);
 	this->addAction(backspaceAction);
 	connect(backspaceAction, &QAction::triggered, this, &WorksheetView::deleteElement);
 
 	//Zoom actions
 	zoomInViewAction = new QAction(QIcon::fromTheme("zoom-in"), i18n("Zoom In"), this);
 
 	zoomOutViewAction = new QAction(QIcon::fromTheme("zoom-out"), i18n("Zoom Out"), this);
 
 	zoomOriginAction = new QAction(QIcon::fromTheme("zoom-original"), i18n("Original Size"), this);
 }
 
 void WorksheetView::initActions() {
 	auto* addNewActionGroup = new QActionGroup(this);
 	auto* zoomActionGroup = new QActionGroup(this);
 	auto* mouseModeActionGroup = new QActionGroup(this);
 	auto* layoutActionGroup = new QActionGroup(this);
 	auto* gridActionGroup = new QActionGroup(this);
 	gridActionGroup->setExclusive(true);
 	auto* magnificationActionGroup = new QActionGroup(this);
 
 	zoomActionGroup->addAction(zoomInViewAction);
 	zoomActionGroup->addAction(zoomOutViewAction);
 	zoomActionGroup->addAction(zoomOriginAction);
 
 	zoomFitPageHeightAction = new QAction(QIcon::fromTheme("zoom-fit-height"), i18n("Fit to Height"), zoomActionGroup);
 	zoomFitPageWidthAction = new QAction(QIcon::fromTheme("zoom-fit-width"), i18n("Fit to Width"), zoomActionGroup);
 	zoomFitSelectionAction = new QAction(i18n("Fit to Selection"), zoomActionGroup);
 
 	// Mouse mode actions
 	selectionModeAction = new QAction(QIcon::fromTheme("labplot-cursor-arrow"), i18n("Select and Edit"), mouseModeActionGroup);
 	selectionModeAction->setCheckable(true);
 
 	navigationModeAction = new QAction(QIcon::fromTheme("input-mouse"), i18n("Navigate"), mouseModeActionGroup);
 	navigationModeAction->setCheckable(true);
 
 	zoomSelectionModeAction = new QAction(QIcon::fromTheme("page-zoom"), i18n("Select and Zoom"), mouseModeActionGroup);
 	zoomSelectionModeAction->setCheckable(true);
 
 	//Magnification actions
 	noMagnificationAction = new QAction(QIcon::fromTheme("labplot-1x-zoom"), i18n("No Magnification"), magnificationActionGroup);
 	noMagnificationAction->setCheckable(true);
 	noMagnificationAction->setChecked(true);
 
 	twoTimesMagnificationAction = new QAction(QIcon::fromTheme("labplot-2x-zoom"), i18n("2x Magnification"), magnificationActionGroup);
 	twoTimesMagnificationAction->setCheckable(true);
 
 	threeTimesMagnificationAction = new QAction(QIcon::fromTheme("labplot-3x-zoom"), i18n("3x Magnification"), magnificationActionGroup);
 	threeTimesMagnificationAction->setCheckable(true);
 
 	fourTimesMagnificationAction = new QAction(QIcon::fromTheme("labplot-4x-zoom"), i18n("4x Magnification"), magnificationActionGroup);
 	fourTimesMagnificationAction->setCheckable(true);
 
 	fiveTimesMagnificationAction = new QAction(QIcon::fromTheme("labplot-5x-zoom"), i18n("5x Magnification"), magnificationActionGroup);
 	fiveTimesMagnificationAction->setCheckable(true);
 
 	//TODO implement later "group selection action" where multiple objects can be selected by drawing a rectangular
 // 	selectionModeAction = new QAction(QIcon::fromTheme("select-rectangular"), i18n("Selection"), mouseModeActionGroup);
 // 	selectionModeAction->setCheckable(true);
 
 	//"Add new" related actions
 	addCartesianPlot1Action = new QAction(QIcon::fromTheme("labplot-xy-plot-four-axes"), i18n("Box Plot, Four Axes"), addNewActionGroup);
 	addCartesianPlot2Action = new QAction(QIcon::fromTheme("labplot-xy-plot-two-axes"), i18n("Box Plot, Two Axes"), addNewActionGroup);
 	addCartesianPlot3Action = new QAction(QIcon::fromTheme("labplot-xy-plot-two-axes-centered"), i18n("Two Axes, Centered"), addNewActionGroup);
 	addCartesianPlot4Action = new QAction(QIcon::fromTheme("labplot-xy-plot-two-axes-centered-origin"), i18n("Two Axes, Crossing at Origin"), addNewActionGroup);
 	addTextLabelAction = new QAction(QIcon::fromTheme("draw-text"), i18n("Text Label"), addNewActionGroup);
 	addImageAction = new QAction(QIcon::fromTheme("viewimage"), i18n("Image"), addNewActionGroup);
 
 	//Layout actions
 	verticalLayoutAction = new QAction(QIcon::fromTheme("labplot-editvlayout"), i18n("Vertical Layout"), layoutActionGroup);
 	verticalLayoutAction->setCheckable(true);
 
 	horizontalLayoutAction = new QAction(QIcon::fromTheme("labplot-edithlayout"), i18n("Horizontal Layout"), layoutActionGroup);
 	horizontalLayoutAction->setCheckable(true);
 
 	gridLayoutAction = new QAction(QIcon::fromTheme("labplot-editgrid"), i18n("Grid Layout"), layoutActionGroup);
 	gridLayoutAction->setCheckable(true);
 
 	breakLayoutAction = new QAction(QIcon::fromTheme("labplot-editbreaklayout"), i18n("Break Layout"), layoutActionGroup);
 	breakLayoutAction->setEnabled(false);
 
 	//Grid actions
 	noGridAction = new QAction(i18n("No Grid"), gridActionGroup);
 	noGridAction->setCheckable(true);
 	noGridAction->setChecked(true);
 	noGridAction->setData(WorksheetView::NoGrid);
 
 	denseLineGridAction = new QAction(i18n("Dense Line Grid"), gridActionGroup);
 	denseLineGridAction->setCheckable(true);
 
 	sparseLineGridAction = new QAction(i18n("Sparse Line Grid"), gridActionGroup);
 	sparseLineGridAction->setCheckable(true);
 
 	denseDotGridAction = new QAction(i18n("Dense Dot Grid"), gridActionGroup);
 	denseDotGridAction->setCheckable(true);
 
 	sparseDotGridAction = new QAction(i18n("Sparse Dot Grid"), gridActionGroup);
 	sparseDotGridAction->setCheckable(true);
 
 	customGridAction = new QAction(i18n("Custom Grid"), gridActionGroup);
 	customGridAction->setCheckable(true);
 
 	snapToGridAction = new QAction(i18n("Snap to Grid"), this);
 	snapToGridAction->setCheckable(true);
 
 	showPresenterMode = new QAction(QIcon::fromTheme("view-fullscreen"), i18n("Show in Presenter Mode"), this);
 
 	//check the action corresponding to the currently active layout in worksheet
 	this->layoutChanged(m_worksheet->layout());
 
 	connect(addNewActionGroup, &QActionGroup::triggered, this, &WorksheetView::addNew);
 	connect(mouseModeActionGroup, &QActionGroup::triggered, this, &WorksheetView::mouseModeChanged);
 	connect(zoomActionGroup, &QActionGroup::triggered, this, &WorksheetView::changeZoom);
 	connect(magnificationActionGroup, &QActionGroup::triggered, this, &WorksheetView::magnificationChanged);
 	connect(layoutActionGroup, &QActionGroup::triggered, this, &WorksheetView::changeLayout);
 	connect(gridActionGroup, &QActionGroup::triggered, this, &WorksheetView::changeGrid);
 	connect(snapToGridAction, &QAction::triggered, this, &WorksheetView::changeSnapToGrid);
 	connect(showPresenterMode, &QAction::triggered, this, &WorksheetView::presenterMode);
 
 	//worksheet control actions
 	plotsLockedAction = new QAction(i18n("Non-interactive Plots"), this);
 	plotsLockedAction->setToolTip(i18n("If activated, plots on the worksheet don't react on drag and mouse wheel events."));
 	plotsLockedAction->setCheckable(true);
 	plotsLockedAction->setChecked(m_worksheet->plotsLocked());
 	connect(plotsLockedAction, &QAction::triggered, this, &WorksheetView::plotsLockedActionChanged);
 
 	//action for cartesian plots
 	auto* cartesianPlotActionModeActionGroup = new QActionGroup(this);
 	cartesianPlotActionModeActionGroup->setExclusive(true);
 	cartesianPlotApplyToSelectionAction = new QAction(i18n("Selected Plots"), cartesianPlotActionModeActionGroup);
 	cartesianPlotApplyToSelectionAction->setCheckable(true);
 	cartesianPlotApplyToAllAction = new QAction(i18n("All Plots"), cartesianPlotActionModeActionGroup);
 	cartesianPlotApplyToAllAction->setCheckable(true);
 	setCartesianPlotActionMode(m_worksheet->cartesianPlotActionMode());
 	connect(cartesianPlotActionModeActionGroup, &QActionGroup::triggered, this, &WorksheetView::cartesianPlotActionModeChanged);
 
 	// cursor apply to all/selected
 	auto* cartesianPlotActionCursorGroup = new QActionGroup(this);
 	cartesianPlotActionCursorGroup->setExclusive(true);
 	cartesianPlotApplyToSelectionCursor = new QAction(i18n("Selected Plots"), cartesianPlotActionCursorGroup);
 	cartesianPlotApplyToSelectionCursor->setCheckable(true);
 	cartesianPlotApplyToAllCursor = new QAction(i18n("All Plots"), cartesianPlotActionCursorGroup);
 	cartesianPlotApplyToAllCursor->setCheckable(true);
 	setCartesianPlotCursorMode(m_worksheet->cartesianPlotCursorMode());
 	connect(cartesianPlotActionCursorGroup, SIGNAL(triggered(QAction*)), SLOT(cartesianPlotCursorModeChanged(QAction*)));
 
 	auto* cartesianPlotMouseModeActionGroup = new QActionGroup(this);
 	cartesianPlotMouseModeActionGroup->setExclusive(true);
 	cartesianPlotSelectionModeAction = new QAction(QIcon::fromTheme("labplot-cursor-arrow"), i18n("Select and Edit"), cartesianPlotMouseModeActionGroup);
 	cartesianPlotSelectionModeAction->setCheckable(true);
 	cartesianPlotSelectionModeAction->setChecked(true);
 
 	cartesianPlotZoomSelectionModeAction = new QAction(QIcon::fromTheme("labplot-zoom-select"), i18n("Select Region and Zoom In"), cartesianPlotMouseModeActionGroup);
 	cartesianPlotZoomSelectionModeAction->setCheckable(true);
 
 	cartesianPlotZoomXSelectionModeAction = new QAction(QIcon::fromTheme("labplot-zoom-select-x"), i18n("Select x-region and Zoom In"), cartesianPlotMouseModeActionGroup);
 	cartesianPlotZoomXSelectionModeAction->setCheckable(true);
 
 	cartesianPlotZoomYSelectionModeAction = new QAction(QIcon::fromTheme("labplot-zoom-select-y"), i18n("Select y-region and Zoom In"), cartesianPlotMouseModeActionGroup);
 	cartesianPlotZoomYSelectionModeAction->setCheckable(true);
 
 	// TODO: change ICON
 	cartesianPlotCursorModeAction = new QAction(QIcon::fromTheme("debug-execute-from-cursor"), i18n("Cursor"), cartesianPlotMouseModeActionGroup);
 	cartesianPlotCursorModeAction->setCheckable(true);
 
 	connect(cartesianPlotMouseModeActionGroup, SIGNAL(triggered(QAction*)), SLOT(cartesianPlotMouseModeChanged(QAction*)));
 
 	auto* cartesianPlotAddNewActionGroup = new QActionGroup(this);
 	addCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("xy-curve"), cartesianPlotAddNewActionGroup);
 	addHistogramAction = new QAction(QIcon::fromTheme("view-object-histogram-linear"), i18n("Histogram"), cartesianPlotAddNewActionGroup);
 	addEquationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-equation-curve"), i18n("xy-curve from a mathematical Equation"), cartesianPlotAddNewActionGroup);
 	// TODO: no own icons yet
 	addDataOperationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Operation"), cartesianPlotAddNewActionGroup);
 //	addDataOperationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-data-operation-curve"), i18n("Data Operation"), cartesianPlotAddNewActionGroup);
 	addDataReductionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Reduction"), cartesianPlotAddNewActionGroup);
 //	addDataReductionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-data-reduction-curve"), i18n("Data Reduction"), cartesianPlotAddNewActionGroup);
 	addDifferentiationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Differentiation"), cartesianPlotAddNewActionGroup);
 //	addDifferentiationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-differentiation-curve"), i18n("Differentiation"), cartesianPlotAddNewActionGroup);
 	addIntegrationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Integration"), cartesianPlotAddNewActionGroup);
 //	addIntegrationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-integration-curve"), i18n("Integration"), cartesianPlotAddNewActionGroup);
 	addConvolutionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("(De-)Convolution"), cartesianPlotAddNewActionGroup);
 //	addConvolutionCurveAction = new QAction(QIcon::fromTheme("labplot-xy-convolution-curve"), i18n("(De-)Convolution"), cartesianPlotAddNewActionGroup);
 	addCorrelationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Auto-/Cross-Correlation"), cartesianPlotAddNewActionGroup);
 //	addCorrelationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-convolution-curve"), i18n("Auto-/Cross-Correlation"), cartesianPlotAddNewActionGroup);
 	addInterpolationCurveAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("Interpolation"), cartesianPlotAddNewActionGroup);
 	addSmoothCurveAction = new QAction(QIcon::fromTheme("labplot-xy-smoothing-curve"), i18n("Smooth"), cartesianPlotAddNewActionGroup);
 	addFitCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Fit"), cartesianPlotAddNewActionGroup);
 	addFourierFilterCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-filter-curve"), i18n("Fourier Filter"), cartesianPlotAddNewActionGroup);
 	addFourierTransformCurveAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-transform-curve"), i18n("Fourier Transform"), cartesianPlotAddNewActionGroup);
 	addLegendAction = new QAction(QIcon::fromTheme("text-field"), i18n("Legend"), cartesianPlotAddNewActionGroup);
 	addHorizontalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-horizontal"), i18n("Horizontal Axis"), cartesianPlotAddNewActionGroup);
 	addVerticalAxisAction = new QAction(QIcon::fromTheme("labplot-axis-vertical"), i18n("Vertical Axis"), cartesianPlotAddNewActionGroup);
 	addPlotTextLabelAction = new QAction(QIcon::fromTheme("draw-text"), i18n("Text Label"), cartesianPlotAddNewActionGroup);
+	addPlotImageAction = new QAction(QIcon::fromTheme("viewimage"), i18n("Image"), cartesianPlotAddNewActionGroup);
 	addCustomPointAction = new QAction(QIcon::fromTheme("draw-cross"), i18n("Custom Point"), cartesianPlotAddNewActionGroup);
 
 	// Analysis menu
 	// TODO: no own icons yet
 	addDataOperationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Operation"), cartesianPlotAddNewActionGroup);
 //	addDataOperationAction = new QAction(QIcon::fromTheme("labplot-xy-data-operation-curve"), i18n("Data Operation"), cartesianPlotAddNewActionGroup);
 	addDataReductionAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Data Reduction"), cartesianPlotAddNewActionGroup);
 //	addDataReductionAction = new QAction(QIcon::fromTheme("labplot-xy-data-reduction-curve"), i18n("Data Reduction"), cartesianPlotAddNewActionGroup);
 	addDifferentiationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Differentiation"), cartesianPlotAddNewActionGroup);
 //	addDifferentiationAction = new QAction(QIcon::fromTheme("labplot-xy-differentiation-curve"), i18n("Differentiation"), cartesianPlotAddNewActionGroup);
 	addIntegrationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Integration"), cartesianPlotAddNewActionGroup);
 //	addIntegrationAction = new QAction(QIcon::fromTheme("labplot-xy-integration-curve"), i18n("Integration"), cartesianPlotAddNewActionGroup);
 	addConvolutionAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Convolution/Deconvolution"), cartesianPlotAddNewActionGroup);
 //	addConvolutionAction = new QAction(QIcon::fromTheme("labplot-xy-convolution-curve"), i18n("Convolution/Deconvolution"), cartesianPlotAddNewActionGroup);
 	addCorrelationAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("Auto-/Cross-Correlation"), cartesianPlotAddNewActionGroup);
 //	addCorrelationAction = new QAction(QIcon::fromTheme("labplot-xy-correlation-curve"), i18n("Auto-/Cross-Correlation"), cartesianPlotAddNewActionGroup);
 
 	addInterpolationAction = new QAction(QIcon::fromTheme("labplot-xy-interpolation-curve"), i18n("Interpolation"), cartesianPlotAddNewActionGroup);
 	addSmoothAction = new QAction(QIcon::fromTheme("labplot-xy-smoothing-curve"), i18n("Smooth"), cartesianPlotAddNewActionGroup);
 	addFitAction = new QAction(QIcon::fromTheme("labplot-xy-fit-curve"), i18n("Fit"), cartesianPlotAddNewActionGroup);
 	addFourierFilterAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-filter-curve"), i18n("Fourier Filter"), cartesianPlotAddNewActionGroup);
 	addFourierTransformAction = new QAction(QIcon::fromTheme("labplot-xy-fourier-transform-curve"), i18n("Fourier Transform"), cartesianPlotAddNewActionGroup);
 
 	connect(cartesianPlotAddNewActionGroup, &QActionGroup::triggered, this, &WorksheetView::cartesianPlotAddNew);
 
 	auto* cartesianPlotNavigationGroup = new QActionGroup(this);
 	scaleAutoAction = new QAction(QIcon::fromTheme("labplot-auto-scale-all"), i18n("Auto Scale"), cartesianPlotNavigationGroup);
 	scaleAutoAction->setData(CartesianPlot::ScaleAuto);
 	scaleAutoXAction = new QAction(QIcon::fromTheme("labplot-auto-scale-x"), i18n("Auto Scale X"), cartesianPlotNavigationGroup);
 	scaleAutoXAction->setData(CartesianPlot::ScaleAutoX);
 	scaleAutoYAction = new QAction(QIcon::fromTheme("labplot-auto-scale-y"), i18n("Auto Scale Y"), cartesianPlotNavigationGroup);
 	scaleAutoYAction->setData(CartesianPlot::ScaleAutoY);
 	zoomInAction = new QAction(QIcon::fromTheme("zoom-in"), i18n("Zoom In"), cartesianPlotNavigationGroup);
 	zoomInAction->setData(CartesianPlot::ZoomIn);
 	zoomOutAction = new QAction(QIcon::fromTheme("zoom-out"), i18n("Zoom Out"), cartesianPlotNavigationGroup);
 	zoomOutAction->setData(CartesianPlot::ZoomOut);
 	zoomInXAction = new QAction(QIcon::fromTheme("labplot-zoom-in-x"), i18n("Zoom In X"), cartesianPlotNavigationGroup);
 	zoomInXAction->setData(CartesianPlot::ZoomInX);
 	zoomOutXAction = new QAction(QIcon::fromTheme("labplot-zoom-out-x"), i18n("Zoom Out X"), cartesianPlotNavigationGroup);
 	zoomOutXAction->setData(CartesianPlot::ZoomOutX);
 	zoomInYAction = new QAction(QIcon::fromTheme("labplot-zoom-in-y"), i18n("Zoom In Y"), cartesianPlotNavigationGroup);
 	zoomInYAction->setData(CartesianPlot::ZoomInY);
 	zoomOutYAction = new QAction(QIcon::fromTheme("labplot-zoom-out-y"), i18n("Zoom Out Y"), cartesianPlotNavigationGroup);
 	zoomOutYAction->setData(CartesianPlot::ZoomOutY);
 	shiftLeftXAction = new QAction(QIcon::fromTheme("labplot-shift-left-x"), i18n("Shift Left X"), cartesianPlotNavigationGroup);
 	shiftLeftXAction->setData(CartesianPlot::ShiftLeftX);
 	shiftRightXAction = new QAction(QIcon::fromTheme("labplot-shift-right-x"), i18n("Shift Right X"), cartesianPlotNavigationGroup);
 	shiftRightXAction->setData(CartesianPlot::ShiftRightX);
 	shiftUpYAction = new QAction(QIcon::fromTheme("labplot-shift-up-y"), i18n("Shift Up Y"), cartesianPlotNavigationGroup);
 	shiftUpYAction->setData(CartesianPlot::ShiftUpY);
 	shiftDownYAction = new QAction(QIcon::fromTheme("labplot-shift-down-y"), i18n("Shift Down Y"), cartesianPlotNavigationGroup);
 	shiftDownYAction->setData(CartesianPlot::ShiftDownY);
 
 	connect(cartesianPlotNavigationGroup, &QActionGroup::triggered, this, &WorksheetView::cartesianPlotNavigationChanged);
 
 	//set some default values
 	selectionModeAction->setChecked(true);
 	handleCartesianPlotActions();
 	currentZoomAction = zoomInViewAction;
 	currentMagnificationAction = noMagnificationAction;
 
 	m_actionsInitialized = true;
 }
 
 void WorksheetView::initMenus() {
 	if (!m_actionsInitialized)
 		initActions();
 
 	m_addNewCartesianPlotMenu = new QMenu(i18n("xy-plot"), this);
 	m_addNewCartesianPlotMenu->addAction(addCartesianPlot1Action);
 	m_addNewCartesianPlotMenu->addAction(addCartesianPlot2Action);
 	m_addNewCartesianPlotMenu->addAction(addCartesianPlot3Action);
 	m_addNewCartesianPlotMenu->addAction(addCartesianPlot4Action);
 
 	m_addNewMenu = new QMenu(i18n("Add New"), this);
 	m_addNewMenu->setIcon(QIcon::fromTheme("list-add"));
 	m_addNewMenu->addMenu(m_addNewCartesianPlotMenu)->setIcon(QIcon::fromTheme("office-chart-line"));
 	m_addNewMenu->addSeparator();
 	m_addNewMenu->addAction(addTextLabelAction);
 	m_addNewMenu->addAction(addImageAction);
 
 	m_viewMouseModeMenu = new QMenu(i18n("Mouse Mode"), this);
 	m_viewMouseModeMenu->setIcon(QIcon::fromTheme("input-mouse"));
 	m_viewMouseModeMenu->addAction(selectionModeAction);
 	m_viewMouseModeMenu->addAction(navigationModeAction);
 	m_viewMouseModeMenu->addAction(zoomSelectionModeAction);
 
 	m_zoomMenu = new QMenu(i18n("Zoom"), this);
 	m_zoomMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	m_zoomMenu->addAction(zoomInViewAction);
 	m_zoomMenu->addAction(zoomOutViewAction);
 	m_zoomMenu->addAction(zoomOriginAction);
 	m_zoomMenu->addAction(zoomFitPageHeightAction);
 	m_zoomMenu->addAction(zoomFitPageWidthAction);
 	m_zoomMenu->addAction(zoomFitSelectionAction);
 
 	m_magnificationMenu = new QMenu(i18n("Magnification"), this);
 	m_magnificationMenu->setIcon(QIcon::fromTheme("zoom-in"));
 	m_magnificationMenu->addAction(noMagnificationAction);
 	m_magnificationMenu->addAction(twoTimesMagnificationAction);
 	m_magnificationMenu->addAction(threeTimesMagnificationAction);
 	m_magnificationMenu->addAction(fourTimesMagnificationAction);
 	m_magnificationMenu->addAction(fiveTimesMagnificationAction);
 
 	m_layoutMenu = new QMenu(i18n("Layout"), this);
 	m_layoutMenu->setIcon(QIcon::fromTheme("labplot-editbreaklayout"));
 	m_layoutMenu->addAction(verticalLayoutAction);
 	m_layoutMenu->addAction(horizontalLayoutAction);
 	m_layoutMenu->addAction(gridLayoutAction);
 	m_layoutMenu->addSeparator();
 	m_layoutMenu->addAction(breakLayoutAction);
 
 	m_gridMenu = new QMenu(i18n("Grid"), this);
 	m_gridMenu->setIcon(QIcon::fromTheme("view-grid"));
 	m_gridMenu->addAction(noGridAction);
 	m_gridMenu->addSeparator();
 	m_gridMenu->addAction(sparseLineGridAction);
 	m_gridMenu->addAction(denseLineGridAction);
 	m_gridMenu->addSeparator();
 	m_gridMenu->addAction(sparseDotGridAction);
 	m_gridMenu->addAction(denseDotGridAction);
 	m_gridMenu->addSeparator();
 	m_gridMenu->addAction(customGridAction);
 	//TODO: implement "snap to grid" and activate this action
 // 	m_gridMenu->addSeparator();
 // 	m_gridMenu->addAction(snapToGridAction);
 
 	m_cartesianPlotMenu = new QMenu(i18n("Cartesian Plot"), this);
 	m_cartesianPlotMenu->setIcon(QIcon::fromTheme("office-chart-line"));
 
 	m_cartesianPlotMouseModeMenu = new QMenu(i18n("Mouse Mode"), this);
 	m_cartesianPlotMouseModeMenu->setIcon(QIcon::fromTheme("input-mouse"));
 	m_cartesianPlotMouseModeMenu->addAction(cartesianPlotSelectionModeAction);
 	m_cartesianPlotMouseModeMenu->addAction(cartesianPlotZoomSelectionModeAction);
 	m_cartesianPlotMouseModeMenu->addAction(cartesianPlotZoomXSelectionModeAction);
 	m_cartesianPlotMouseModeMenu->addAction(cartesianPlotZoomYSelectionModeAction);
 	m_cartesianPlotMouseModeMenu->addSeparator();
 	m_cartesianPlotMouseModeMenu->addAction(cartesianPlotCursorModeAction);
 	m_cartesianPlotMouseModeMenu->addSeparator();
 
 	m_cartesianPlotAddNewMenu = new QMenu(i18n("Add New"), this);
 	m_cartesianPlotAddNewMenu->setIcon(QIcon::fromTheme("list-add"));
 	m_cartesianPlotAddNewMenu->addAction(addCurveAction);
 	m_cartesianPlotAddNewMenu->addAction(addHistogramAction);
 	m_cartesianPlotAddNewMenu->addAction(addEquationCurveAction);
 	m_cartesianPlotAddNewMenu->addSeparator();
 
 	m_cartesianPlotAddNewAnalysisMenu = new QMenu(i18n("Analysis Curve"));
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addFitCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addSeparator();
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addDifferentiationCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addIntegrationCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addSeparator();
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addInterpolationCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addSmoothCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addSeparator();
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addFourierFilterCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addFourierTransformCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addSeparator();
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addConvolutionCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addCorrelationCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addSeparator();
 // 	m_cartesianPlotAddNewAnalysisMenu->addAction(addDataOperationCurveAction);
 	m_cartesianPlotAddNewAnalysisMenu->addAction(addDataReductionCurveAction);
 	m_cartesianPlotAddNewMenu->addMenu(m_cartesianPlotAddNewAnalysisMenu);
 
 	m_cartesianPlotAddNewMenu->addSeparator();
 	m_cartesianPlotAddNewMenu->addAction(addLegendAction);
 	m_cartesianPlotAddNewMenu->addSeparator();
 	m_cartesianPlotAddNewMenu->addAction(addHorizontalAxisAction);
 	m_cartesianPlotAddNewMenu->addAction(addVerticalAxisAction);
 	m_cartesianPlotAddNewMenu->addSeparator();
 	m_cartesianPlotAddNewMenu->addAction(addPlotTextLabelAction);
+	m_cartesianPlotAddNewMenu->addAction(addPlotImageAction);
 	m_cartesianPlotAddNewMenu->addSeparator();
 	m_cartesianPlotAddNewMenu->addAction(addCustomPointAction);
 
 	m_cartesianPlotZoomMenu = new QMenu(i18n("Zoom/Navigate"), this);
 	m_cartesianPlotZoomMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	m_cartesianPlotZoomMenu->addAction(scaleAutoAction);
 	m_cartesianPlotZoomMenu->addAction(scaleAutoXAction);
 	m_cartesianPlotZoomMenu->addAction(scaleAutoYAction);
 	m_cartesianPlotZoomMenu->addSeparator();
 	m_cartesianPlotZoomMenu->addAction(zoomInAction);
 	m_cartesianPlotZoomMenu->addAction(zoomOutAction);
 	m_cartesianPlotZoomMenu->addSeparator();
 	m_cartesianPlotZoomMenu->addAction(zoomInXAction);
 	m_cartesianPlotZoomMenu->addAction(zoomOutXAction);
 	m_cartesianPlotZoomMenu->addSeparator();
 	m_cartesianPlotZoomMenu->addAction(zoomInYAction);
 	m_cartesianPlotZoomMenu->addAction(zoomOutYAction);
 	m_cartesianPlotZoomMenu->addSeparator();
 	m_cartesianPlotZoomMenu->addAction(shiftLeftXAction);
 	m_cartesianPlotZoomMenu->addAction(shiftRightXAction);
 	m_cartesianPlotZoomMenu->addSeparator();
 	m_cartesianPlotZoomMenu->addAction(shiftUpYAction);
 	m_cartesianPlotZoomMenu->addAction(shiftDownYAction);
 
 	m_cartesianPlotActionModeMenu = new QMenu(i18n("Apply Actions to"), this);
 	m_cartesianPlotActionModeMenu->setIcon(QIcon::fromTheme("dialog-ok-apply"));
 	m_cartesianPlotActionModeMenu->addAction(cartesianPlotApplyToSelectionAction);
 	m_cartesianPlotActionModeMenu->addAction(cartesianPlotApplyToAllAction);
 
 	m_cartesianPlotCursorModeMenu = new QMenu(i18n("Apply Cursor to"), this);
 	m_cartesianPlotCursorModeMenu->addAction(cartesianPlotApplyToSelectionCursor);
 	m_cartesianPlotCursorModeMenu->addAction(cartesianPlotApplyToAllCursor);
 
 	m_cartesianPlotMenu->addMenu(m_cartesianPlotAddNewMenu);
 	m_cartesianPlotMenu->addSeparator();
 	m_cartesianPlotMenu->addMenu(m_cartesianPlotMouseModeMenu);
 	m_cartesianPlotMenu->addMenu(m_cartesianPlotZoomMenu);
 	m_cartesianPlotMenu->addSeparator();
 	m_cartesianPlotMenu->addMenu(m_cartesianPlotActionModeMenu);
 	m_cartesianPlotMenu->addMenu(m_cartesianPlotCursorModeMenu);
 	m_cartesianPlotMenu->addSeparator();
 	m_cartesianPlotMenu->addAction(plotsLockedAction);
 
 	// Data manipulation menu
 	m_dataManipulationMenu = new QMenu(i18n("Data Manipulation") ,this);
 	m_dataManipulationMenu->setIcon(QIcon::fromTheme("zoom-draw"));
 	m_dataManipulationMenu->addAction(addDataOperationAction);
 	m_dataManipulationMenu->addAction(addDataReductionAction);
 
 	//themes menu
 	m_themeMenu = new QMenu(i18n("Apply Theme"), this);
 	m_themeMenu->setIcon(QIcon::fromTheme("color-management"));
 	auto* themeWidget = new ThemesWidget(nullptr);
 	connect(themeWidget, &ThemesWidget::themeSelected, m_worksheet, &Worksheet::setTheme);
 	connect(themeWidget, &ThemesWidget::themeSelected, m_themeMenu, &QMenu::close);
 
 	auto* widgetAction = new QWidgetAction(this);
 	widgetAction->setDefaultWidget(themeWidget);
 	m_themeMenu->addAction(widgetAction);
 
 	m_menusInitialized = true;
 }
 
 /*!
  * Populates the menu \c menu with the worksheet and worksheet view relevant actions.
  * The menu is used
  *   - as the context menu in WorksheetView
  *   - as the "worksheet menu" in the main menu-bar (called form MainWin)
  *   - as a part of the worksheet context menu in project explorer
  */
 void WorksheetView::createContextMenu(QMenu* menu) {
 	Q_ASSERT(menu != nullptr);
 
 	if (!m_menusInitialized)
 		initMenus();
 
 	QAction* firstAction = nullptr;
 	// if we're populating the context menu for the project explorer, then
 	//there're already actions available there. Skip the first title-action
 	//and insert the action at the beginning of the menu.
 	if (menu->actions().size() > 1)
 		firstAction = menu->actions().at(1);
 
 	menu->insertMenu(firstAction, m_addNewMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, m_viewMouseModeMenu);
 	menu->insertMenu(firstAction, m_zoomMenu);
 	menu->insertMenu(firstAction, m_magnificationMenu);
 	menu->insertMenu(firstAction, m_layoutMenu);
 	menu->insertMenu(firstAction, m_gridMenu);
 	menu->insertMenu(firstAction, m_themeMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, plotsLockedAction);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, m_cartesianPlotMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, showPresenterMode);
 	menu->insertSeparator(firstAction);
 }
 
 void WorksheetView::createAnalysisMenu(QMenu* menu) {
 	Q_ASSERT(menu != nullptr);
 
 	if (!m_menusInitialized)
 		initMenus();
 
 	// Data manipulation menu
 // 	menu->insertMenu(nullptr, m_dataManipulationMenu);
 
 	menu->addAction(addFitAction);
 	menu->addSeparator();
 	menu->addAction(addDifferentiationAction);
 	menu->addAction(addIntegrationAction);
 	menu->addSeparator();
 	menu->addAction(addInterpolationAction);
 	menu->addAction(addSmoothAction);
 	menu->addSeparator();
 	menu->addAction(addFourierFilterAction);
 	menu->addAction(addFourierTransformAction);
 	menu->addSeparator();
 	menu->addAction(addConvolutionAction);
 	menu->addAction(addCorrelationAction);
 	menu->addSeparator();
 	menu->addAction(addDataReductionAction);
 }
 
 void WorksheetView::fillToolBar(QToolBar* toolBar) {
 	toolBar->addSeparator();
 	tbNewCartesianPlot = new QToolButton(toolBar);
 	tbNewCartesianPlot->setPopupMode(QToolButton::MenuButtonPopup);
 	tbNewCartesianPlot->setMenu(m_addNewCartesianPlotMenu);
 	tbNewCartesianPlot->setDefaultAction(addCartesianPlot1Action);
 	toolBar->addWidget(tbNewCartesianPlot);
 	toolBar->addAction(addTextLabelAction);
 	toolBar->addAction(addImageAction);
 
 	toolBar->addSeparator();
 	toolBar->addAction(verticalLayoutAction);
 	toolBar->addAction(horizontalLayoutAction);
 	toolBar->addAction(gridLayoutAction);
 	toolBar->addAction(breakLayoutAction);
 
 	toolBar->addSeparator();
 	toolBar->addAction(selectionModeAction);
 	toolBar->addAction(navigationModeAction);
 	toolBar->addAction(zoomSelectionModeAction);
 	toolBar->addSeparator();
 	tbZoom = new QToolButton(toolBar);
 	tbZoom->setPopupMode(QToolButton::MenuButtonPopup);
 	tbZoom->setMenu(m_zoomMenu);
 	tbZoom->setDefaultAction(currentZoomAction);
 	toolBar->addWidget(tbZoom);
 
 	tbMagnification = new QToolButton(toolBar);
 	tbMagnification->setPopupMode(QToolButton::MenuButtonPopup);
 	tbMagnification->setMenu(m_magnificationMenu);
 	tbMagnification->setDefaultAction(currentMagnificationAction);
 	toolBar->addWidget(tbMagnification);
 }
 
 #ifdef Q_OS_MAC
 void WorksheetView::fillTouchBar(KDMacTouchBar* touchBar){
 	//touchBar->addAction(addCartesianPlot1Action);
 	touchBar->addAction(zoomInViewAction);
 	touchBar->addAction(zoomOutViewAction);
 	touchBar->addAction(showPresenterMode);
 }
 #endif
 
 void WorksheetView::fillCartesianPlotToolBar(QToolBar* toolBar) {
 	toolBar->addAction(cartesianPlotSelectionModeAction);
 	toolBar->addAction(cartesianPlotZoomSelectionModeAction);
 	toolBar->addAction(cartesianPlotZoomXSelectionModeAction);
 	toolBar->addAction(cartesianPlotZoomYSelectionModeAction);
 	toolBar->addAction(cartesianPlotCursorModeAction);
 	toolBar->addSeparator();
 	toolBar->addAction(addCurveAction);
 	toolBar->addAction(addHistogramAction);
 	toolBar->addAction(addEquationCurveAction);
 // don't over-populate the tool bar
 //	toolBar->addAction(addDifferentiationCurveAction);
 //	toolBar->addAction(addIntegrationCurveAction);
 //	toolBar->addAction(addDataOperationCurveAction);
 //	toolBar->addAction(addDataReductionCurveAction);
 //	toolBar->addAction(addInterpolationCurveAction);
 //	toolBar->addAction(addSmoothCurveAction);
 //	toolBar->addAction(addFitCurveAction);
 //	toolBar->addAction(addFourierFilterCurveAction);
 //	toolBar->addAction(addFourierTransformCurveAction);
 //	toolBar->addAction(addConvolutionCurveAction);
 //	toolBar->addAction(addCorrelationCurveAction);
 	toolBar->addSeparator();
 	toolBar->addAction(addLegendAction);
 	toolBar->addSeparator();
 	toolBar->addAction(addHorizontalAxisAction);
 	toolBar->addAction(addVerticalAxisAction);
 	toolBar->addSeparator();
 	toolBar->addAction(addPlotTextLabelAction);
+	toolBar->addAction(addPlotImageAction);
 	toolBar->addSeparator();
 	toolBar->addAction(scaleAutoAction);
 	toolBar->addAction(scaleAutoXAction);
 	toolBar->addAction(scaleAutoYAction);
 	toolBar->addAction(zoomInAction);
 	toolBar->addAction(zoomOutAction);
 	toolBar->addAction(zoomInXAction);
 	toolBar->addAction(zoomOutXAction);
 	toolBar->addAction(zoomInYAction);
 	toolBar->addAction(zoomOutYAction);
 	toolBar->addAction(shiftLeftXAction);
 	toolBar->addAction(shiftRightXAction);
 	toolBar->addAction(shiftUpYAction);
 	toolBar->addAction(shiftDownYAction);
 	toolBar->addSeparator();
 
 	handleCartesianPlotActions();
 }
 
 void WorksheetView::setScene(QGraphicsScene* scene) {
 	QGraphicsView::setScene(scene);
 }
 
 void WorksheetView::setIsClosing() {
 	m_isClosing = true;
 }
 
 void WorksheetView::setCartesianPlotActionMode(Worksheet::CartesianPlotActionMode mode) {
 	if (mode == Worksheet::CartesianPlotActionMode::ApplyActionToAll)
 		cartesianPlotApplyToAllAction->setChecked(true);
 	else
 		cartesianPlotApplyToSelectionAction->setChecked(true);
 }
 
 void WorksheetView::setCartesianPlotCursorMode(Worksheet::CartesianPlotActionMode mode) {
 	if (mode == Worksheet::CartesianPlotActionMode::ApplyActionToAll)
 		cartesianPlotApplyToAllCursor->setChecked(true);
 	else
 		cartesianPlotApplyToSelectionCursor->setChecked(true);
 }
 
 void WorksheetView::setPlotLock(bool lock) {
 	plotsLockedAction->setChecked(lock);
 }
 
 void WorksheetView::drawForeground(QPainter* painter, const QRectF& rect) {
 	if (m_mouseMode == ZoomSelectionMode && m_selectionBandIsShown) {
 		painter->save();
 		const QRectF& selRect = mapToScene(QRect(m_selectionStart, m_selectionEnd).normalized()).boundingRect();
 		//TODO: don't hardcode for black here, use a a different color depending on the theme of the worksheet/plot under the mouse cursor?
 		painter->setPen(QPen(Qt::black, 5/transform().m11()));
 		painter->drawRect(selRect);
 		painter->setBrush(QApplication::palette().color(QPalette::Highlight));
 		painter->setOpacity(0.2);
 		painter->drawRect(selRect);
 		painter->restore();
 	}
 	QGraphicsView::drawForeground(painter, rect);
 }
 
 void WorksheetView::drawBackgroundItems(QPainter* painter, const QRectF& scene_rect) {
 	// canvas
 	painter->setOpacity(m_worksheet->backgroundOpacity());
 	if (m_worksheet->backgroundType() == PlotArea::Color) {
 		switch (m_worksheet->backgroundColorStyle()) {
 		case PlotArea::SingleColor: {
 				painter->setBrush(QBrush(m_worksheet->backgroundFirstColor()));
 				break;
 			}
 		case PlotArea::HorizontalLinearGradient: {
 				QLinearGradient linearGrad(scene_rect.topLeft(), scene_rect.topRight());
 				linearGrad.setColorAt(0, m_worksheet->backgroundFirstColor());
 				linearGrad.setColorAt(1, m_worksheet->backgroundSecondColor());
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 		case PlotArea::VerticalLinearGradient: {
 				QLinearGradient linearGrad(scene_rect.topLeft(), scene_rect.bottomLeft());
 				linearGrad.setColorAt(0, m_worksheet->backgroundFirstColor());
 				linearGrad.setColorAt(1, m_worksheet->backgroundSecondColor());
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 		case PlotArea::TopLeftDiagonalLinearGradient: {
 				QLinearGradient linearGrad(scene_rect.topLeft(), scene_rect.bottomRight());
 				linearGrad.setColorAt(0, m_worksheet->backgroundFirstColor());
 				linearGrad.setColorAt(1, m_worksheet->backgroundSecondColor());
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 		case PlotArea::BottomLeftDiagonalLinearGradient: {
 				QLinearGradient linearGrad(scene_rect.bottomLeft(), scene_rect.topRight());
 				linearGrad.setColorAt(0, m_worksheet->backgroundFirstColor());
 				linearGrad.setColorAt(1, m_worksheet->backgroundSecondColor());
 				painter->setBrush(QBrush(linearGrad));
 				break;
 			}
 		case PlotArea::RadialGradient: {
 				QRadialGradient radialGrad(scene_rect.center(), scene_rect.width()/2);
 				radialGrad.setColorAt(0, m_worksheet->backgroundFirstColor());
 				radialGrad.setColorAt(1, m_worksheet->backgroundSecondColor());
 				painter->setBrush(QBrush(radialGrad));
 				break;
 			}
 			//default:
 			//	painter->setBrush(QBrush(m_worksheet->backgroundFirstColor()));
 		}
 		painter->drawRect(scene_rect);
 	} else if (m_worksheet->backgroundType() == PlotArea::Image) {	// background image
 		const QString& backgroundFileName = m_worksheet->backgroundFileName().trimmed();
 		if ( !backgroundFileName.isEmpty() ) {
 			QPixmap pix(backgroundFileName);
 			switch (m_worksheet->backgroundImageStyle()) {
 			case PlotArea::ScaledCropped:
 				pix = pix.scaled(scene_rect.size().toSize(),Qt::KeepAspectRatioByExpanding,Qt::SmoothTransformation);
 				painter->drawPixmap(scene_rect.topLeft(),pix);
 				break;
 			case PlotArea::Scaled:
 				pix = pix.scaled(scene_rect.size().toSize(),Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
 				painter->drawPixmap(scene_rect.topLeft(),pix);
 				break;
 			case PlotArea::ScaledAspectRatio:
 				pix = pix.scaled(scene_rect.size().toSize(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
 				painter->drawPixmap(scene_rect.topLeft(),pix);
 				break;
 			case PlotArea::Centered:
 				painter->drawPixmap(QPointF(scene_rect.center().x()-pix.size().width()/2,scene_rect.center().y()-pix.size().height()/2),pix);
 				break;
 			case PlotArea::Tiled:
 				painter->drawTiledPixmap(scene_rect,pix);
 				break;
 			case PlotArea::CenterTiled:
 				painter->drawTiledPixmap(scene_rect,pix,QPoint(scene_rect.size().width()/2,scene_rect.size().height()/2));
 				break;
 				//default:
 				//	painter->drawPixmap(scene_rect.topLeft(),pix);
 			}
 		}
 	} else if (m_worksheet->backgroundType() == PlotArea::Pattern) {	// background pattern
 		painter->setBrush(QBrush(m_worksheet->backgroundFirstColor(),m_worksheet->backgroundBrushStyle()));
 		painter->drawRect(scene_rect);
 	}
 
 	//grid
 	if (m_gridSettings.style != WorksheetView::NoGrid) {
 		QColor c = m_gridSettings.color;
 		c.setAlphaF(m_gridSettings.opacity);
 		painter->setPen(c);
 
 		qreal x, y;
 		qreal left = scene_rect.left();
 		qreal right = scene_rect.right();
 		qreal top = scene_rect.top();
 		qreal bottom = scene_rect.bottom();
 
 		if (m_gridSettings.style == WorksheetView::LineGrid) {
 			QLineF line;
 
 			//horizontal lines
 			y = top + m_gridSettings.verticalSpacing;
 			while (y < bottom) {
 				line.setLine( left, y,  right, y );
 				painter->drawLine(line);
 				y += m_gridSettings.verticalSpacing;
 			}
 
 			//vertical lines
 			x = left + m_gridSettings.horizontalSpacing;
 			while (x < right) {
 				line.setLine( x, top,  x, bottom );
 				painter->drawLine(line);
 				x += m_gridSettings.horizontalSpacing;
 			}
 		} else { //DotGrid
 			y = top + m_gridSettings.verticalSpacing;
 			while (y < bottom) {
 				x = left;// + m_gridSettings.horizontalSpacing;
 				while (x < right) {
 					x += m_gridSettings.horizontalSpacing;
 					painter->drawPoint(x, y);
 				}
 				y += m_gridSettings.verticalSpacing;
 			}
 		}
 	}
 }
 
 void WorksheetView::drawBackground(QPainter* painter, const QRectF& rect) {
 	painter->save();
 
 	//painter->setRenderHint(QPainter::Antialiasing);
 	QRectF scene_rect = sceneRect();
 
 	if (!m_worksheet->useViewSize()) {
 		// background
 		KColorScheme scheme(QPalette::Active, KColorScheme::Window);
 		const QColor& color = scheme.background().color();
 		if (!scene_rect.contains(rect))
 			painter->fillRect(rect, color);
 
 		//shadow
 // 		int shadowSize = scene_rect.width()*0.02;
 // 		QRectF rightShadowRect(scene_rect.right(), scene_rect.top() + shadowSize, shadowSize, scene_rect.height());
 // 		QRectF bottomShadowRect(scene_rect.left() + shadowSize, scene_rect.bottom(), scene_rect.width(), shadowSize);
 //
 // 		const QColor& shadeColor = scheme.shade(color, KColorScheme::MidShade);
 // 		painter->fillRect(rightShadowRect.intersected(rect), shadeColor);
 // 		painter->fillRect(bottomShadowRect.intersected(rect), shadeColor);
 	}
 
 	drawBackgroundItems(painter, scene_rect);
 
 	invalidateScene(rect, QGraphicsScene::BackgroundLayer);
 	painter->restore();
 }
 
 bool WorksheetView::isPlotAtPos(QPoint pos) const {
 	bool plot = false;
 	QGraphicsItem* item = itemAt(pos);
 	if (item) {
 		plot = item->data(0).toInt() == WorksheetElement::NameCartesianPlot;
 		if (!plot && item->parentItem())
 			plot = item->parentItem()->data(0).toInt() == WorksheetElement::NameCartesianPlot;
 	}
 
 	return plot;
 }
 
 CartesianPlot* WorksheetView::plotAt(QPoint pos) const {
 	QGraphicsItem* item = itemAt(pos);
 	if (!item)
 		return nullptr;
 
 	QGraphicsItem* plotItem = nullptr;
 	if (item->data(0).toInt() == WorksheetElement::NameCartesianPlot)
 		plotItem = item;
 	else {
 		if (item->parentItem() && item->parentItem()->data(0).toInt() == WorksheetElement::NameCartesianPlot)
 			plotItem = item->parentItem();
 	}
 
 	if (plotItem == nullptr)
 		return nullptr;
 
 	CartesianPlot* plot = nullptr;
 	for (auto* p : m_worksheet->children<CartesianPlot>()) {
 		if (p->graphicsItem() == plotItem) {
 			plot = p;
 			break;
 		}
 	}
 
 	return plot;
 }
 
 //##############################################################################
 //####################################  Events   ###############################
 //##############################################################################
 void WorksheetView::resizeEvent(QResizeEvent* event) {
 	if (m_isClosing)
 		return;
 
 	if (m_worksheet->useViewSize())
 		this->processResize();
 
 	QGraphicsView::resizeEvent(event);
 }
 
 void WorksheetView::wheelEvent(QWheelEvent* event) {
 	//https://wiki.qt.io/Smooth_Zoom_In_QGraphicsView
 	if (m_mouseMode == ZoomSelectionMode || (QApplication::keyboardModifiers() & Qt::ControlModifier)) {
 		int numDegrees = event->delta() / 8;
 		int numSteps = numDegrees / 15; // see QWheelEvent documentation
 		zoom(numSteps);
 	} else
 		QGraphicsView::wheelEvent(event);
 }
 
 void WorksheetView::zoom(int numSteps) {
 	m_numScheduledScalings += numSteps;
 	if (m_numScheduledScalings * numSteps < 0) // if user moved the wheel in another direction, we reset previously scheduled scalings
 		m_numScheduledScalings = numSteps;
 
 	auto* anim = new QTimeLine(350, this);
 	anim->setUpdateInterval(20);
 
 	connect(anim, &QTimeLine::valueChanged, this, &WorksheetView::scalingTime);
 	connect(anim, &QTimeLine::finished, this, &WorksheetView::animFinished);
 	anim->start();
 }
 
 void WorksheetView::scalingTime() {
 	qreal factor = 1.0 + qreal(m_numScheduledScalings) / 300.0;
 	scale(factor, factor);
 }
 
 void WorksheetView::animFinished() {
 	if (m_numScheduledScalings > 0)
 		m_numScheduledScalings--;
 	else
 		m_numScheduledScalings++;
 	sender()->~QObject();
 }
 
 void WorksheetView::mousePressEvent(QMouseEvent* event) {
 	//prevent the deselection of items when context menu event
 	//was triggered (right button click)
 	if (event->button() == Qt::RightButton) {
 		event->accept();
 		return;
 	}
 
 	if (event->button() == Qt::LeftButton && m_mouseMode == ZoomSelectionMode) {
 		m_selectionStart = event->pos();
 		m_selectionEnd = m_selectionStart; //select&zoom'g starts -> reset the end point to the start point
 		m_selectionBandIsShown = true;
 		QGraphicsView::mousePressEvent(event);
 		return;
 	}
 
 	// select the worksheet in the project explorer if the view was clicked
 	// and there is no selection currently. We need this for the case when
 	// there is a single worksheet in the project and we change from the project-node
 	// in the project explorer to the worksheet-node by clicking the view.
 	if ( scene()->selectedItems().isEmpty() )
 		m_worksheet->setSelectedInView(true);
 
 	QGraphicsView::mousePressEvent(event);
 }
 
 void WorksheetView::mouseReleaseEvent(QMouseEvent* event) {
 	if (event->button() == Qt::LeftButton && m_mouseMode == ZoomSelectionMode) {
 		m_selectionBandIsShown = false;
 		viewport()->repaint(QRect(m_selectionStart, m_selectionEnd).normalized());
 
 		//don't zoom if very small region was selected, avoid occasional/unwanted zooming
 		m_selectionEnd = event->pos();
 		if ( abs(m_selectionEnd.x() - m_selectionStart.x()) > 20 && abs(m_selectionEnd.y() - m_selectionStart.y()) > 20 )
 			fitInView(mapToScene(QRect(m_selectionStart, m_selectionEnd).normalized()).boundingRect(), Qt::KeepAspectRatio);
 	}
 
 	QGraphicsView::mouseReleaseEvent(event);
 }
 
 void WorksheetView::mouseMoveEvent(QMouseEvent* event) {
 	if (m_mouseMode == SelectionMode && m_cartesianPlotMouseMode != CartesianPlot::SelectionMode ) {
 		//check whether there is a cartesian plot under the cursor
 		//and set the cursor appearance according to the current mouse mode for the cartesian plots
 		if ( isPlotAtPos(event->pos()) ) {
 			if (m_cartesianPlotMouseMode == CartesianPlot::ZoomSelectionMode)
 				setCursor(Qt::CrossCursor);
 			else if (m_cartesianPlotMouseMode == CartesianPlot::ZoomXSelectionMode)
 				setCursor(Qt::SizeHorCursor);
 			else if (m_cartesianPlotMouseMode == CartesianPlot::ZoomYSelectionMode)
 				setCursor(Qt::SizeVerCursor);
 		} else
 			setCursor(Qt::ArrowCursor);
 	} else if (m_mouseMode == SelectionMode && m_cartesianPlotMouseMode == CartesianPlot::SelectionMode )
 		setCursor(Qt::ArrowCursor);
 	else if (m_selectionBandIsShown) {
 		QRect rect = QRect(m_selectionStart, m_selectionEnd).normalized();
 		m_selectionEnd = event->pos();
 		rect = rect.united(QRect(m_selectionStart, m_selectionEnd).normalized());
 		qreal penWidth = 5/transform().m11();
 		rect.setX(rect.x()-penWidth);
 		rect.setY(rect.y()-penWidth);
 		rect.setHeight(rect.height()+2*penWidth);
 		rect.setWidth(rect.width()+2*penWidth);
 		viewport()->repaint(rect);
 	}
 
 	//show the magnification window
 	if (magnificationFactor /*&& m_mouseMode == SelectAndEditMode*/) {
 		if (!m_magnificationWindow) {
 			m_magnificationWindow = new QGraphicsPixmapItem(nullptr);
 			m_magnificationWindow->setZValue(std::numeric_limits<int>::max());
 			scene()->addItem(m_magnificationWindow);
 		}
 
 		m_magnificationWindow->setVisible(false);
 
 		//copy the part of the view to be shown magnified
 		QPointF pos = mapToScene(event->pos());
 		const int size = Worksheet::convertToSceneUnits(2.0, Worksheet::Centimeter)/transform().m11();
 
 		const QRectF copyRect(pos.x() - size/(2*magnificationFactor), pos.y() - size/(2*magnificationFactor), size/magnificationFactor, size/magnificationFactor);
 		QPixmap px = grab(mapFromScene(copyRect).boundingRect());
 		px = px.scaled(size, size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
 		//draw the bounding rect
 		QPainter painter(&px);
 		const QPen pen = QPen(Qt::lightGray, 2/transform().m11());
 		painter.setPen(pen);
 		QRect rect = px.rect();
 		rect.setWidth(rect.width()-pen.widthF()/2);
 		rect.setHeight(rect.height()-pen.widthF()/2);
 		painter.drawRect(rect);
 
 		//set the pixmap
 		m_magnificationWindow->setPixmap(px);
 		m_magnificationWindow->setPos(pos.x()- px.width()/2, pos.y()- px.height()/2);
 
 		m_magnificationWindow->setVisible(true);
 	} else if (m_magnificationWindow)
 		m_magnificationWindow->setVisible(false);
 
 	QGraphicsView::mouseMoveEvent(event);
 }
 
 void WorksheetView::contextMenuEvent(QContextMenuEvent* e) {
 	if ( (m_magnificationWindow && m_magnificationWindow->isVisible() && items(e->pos()).size() == 1) || !itemAt(e->pos()) ) {
 		//no item or only the magnification window under the cursor -> show the context menu for the worksheet
 		QMenu *menu = new QMenu(this);
 		this->createContextMenu(menu);
 		menu->exec(QCursor::pos());
 	} else {
 		//propagate the event to the scene and graphics items
 		QGraphicsView::contextMenuEvent(e);
 	}
 }
 
 void WorksheetView::keyPressEvent(QKeyEvent* event) {
 	if (event->matches(QKeySequence::Copy)) {
 		//add here copying of objects
 		exportToClipboard();
 	}
 
 	QGraphicsView::keyPressEvent(event);
 }
 
 void WorksheetView::keyReleaseEvent(QKeyEvent* event) {
 	QGraphicsView::keyReleaseEvent(event);
 }
 
 void WorksheetView::dragEnterEvent(QDragEnterEvent* event) {
 	//ignore events not related to internal drags of columns etc., e.g. dropping of external files onto LabPlot
 	const QMimeData* mimeData = event->mimeData();
 	if (!mimeData) {
 		event->ignore();
 		return;
 	}
 
 	if (mimeData->formats().at(0) != QLatin1String("labplot-dnd")) {
 		event->ignore();
 		return;
 	}
 
 	//select the worksheet in the project explorer and bring the view to the foreground
 	m_worksheet->setSelectedInView(true);
 	m_worksheet->mdiSubWindow()->mdiArea()->setActiveSubWindow(m_worksheet->mdiSubWindow());
 
 	event->setAccepted(true);
 }
 
 void WorksheetView::dragMoveEvent(QDragMoveEvent* event) {
 	// only accept drop events if we have a plot under the cursor where we can drop columns onto
 	bool plot = isPlotAtPos(event->pos());
 	event->setAccepted(plot);
 }
 
 void WorksheetView::dropEvent(QDropEvent* event) {
 	CartesianPlot* plot = plotAt(event->pos());
 	if (plot != nullptr)
 		plot->processDropEvent(event);
 }
 
 //##############################################################################
 //####################################  SLOTs   ################################
 //##############################################################################
 void WorksheetView::useViewSizeRequested() {
 	if (!m_actionsInitialized)
 		initActions();
 
 	if (m_worksheet->useViewSize()) {
 		setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 		setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 		zoomFitPageHeightAction->setVisible(false);
 		zoomFitPageWidthAction->setVisible(false);
 		currentZoomAction = zoomInViewAction;
 		if (tbZoom)
 			tbZoom->setDefaultAction(zoomInViewAction);
 
 		//determine and set the current view size
 		this->processResize();
 	} else {
 		setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 		setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 		zoomFitPageHeightAction->setVisible(true);
 		zoomFitPageWidthAction->setVisible(true);
 	}
 }
 
 void WorksheetView::processResize() {
 	if (size() != sceneRect().size()) {
 		static const float hscale = QApplication::desktop()->physicalDpiX()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 		static const float vscale = QApplication::desktop()->physicalDpiY()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 		m_worksheet->setUndoAware(false);
 		m_worksheet->setPageRect(QRectF(0.0, 0.0, width()/hscale, height()/vscale));
 		m_worksheet->setUndoAware(true);
 	}
 }
 
 void WorksheetView::changeZoom(QAction* action) {
 	if (action == zoomInViewAction)
 		zoom(1);
 	else if (action == zoomOutViewAction)
 		zoom(-1);
 	else if (action == zoomOriginAction) {
 		static const float hscale = QApplication::desktop()->physicalDpiX()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 		static const float vscale = QApplication::desktop()->physicalDpiY()/(Worksheet::convertToSceneUnits(1,Worksheet::Inch));
 		setTransform(QTransform::fromScale(hscale, vscale));
 	} else if (action == zoomFitPageWidthAction) {
 		float scaleFactor = viewport()->width()/scene()->sceneRect().width();
 		setTransform(QTransform::fromScale(scaleFactor, scaleFactor));
 	} else if (action == zoomFitPageHeightAction) {
 		float scaleFactor = viewport()->height()/scene()->sceneRect().height();
 		setTransform(QTransform::fromScale(scaleFactor, scaleFactor));
 	} else if (action == zoomFitSelectionAction)
 		fitInView(scene()->selectionArea().boundingRect(),Qt::KeepAspectRatio);
 	currentZoomAction = action;
 	if (tbZoom)
 		tbZoom->setDefaultAction(action);
 }
 
 void WorksheetView::magnificationChanged(QAction* action) {
 	if (action == noMagnificationAction)
 		magnificationFactor = 0;
 	else if (action == twoTimesMagnificationAction)
 		magnificationFactor = 2;
 	else if (action == threeTimesMagnificationAction)
 		magnificationFactor = 3;
 	else if (action == fourTimesMagnificationAction)
 		magnificationFactor = 4;
 	else if (action == fiveTimesMagnificationAction)
 		magnificationFactor = 5;
 
 	currentMagnificationAction = action;
 	if (tbMagnification)
 		tbMagnification->setDefaultAction(action);
 }
 
 void WorksheetView::mouseModeChanged(QAction* action) {
 	if (action == selectionModeAction) {
 		m_mouseMode = SelectionMode;
 		setInteractive(true);
 		setDragMode(QGraphicsView::NoDrag);
 	} else if (action == navigationModeAction) {
 		m_mouseMode = NavigationMode;
 		setInteractive(false);
 		setDragMode(QGraphicsView::ScrollHandDrag);
 	} else {
 		m_mouseMode = ZoomSelectionMode;
 		setInteractive(false);
 		setDragMode(QGraphicsView::NoDrag);
 	}
 }
 
 //"Add new" related slots
 void WorksheetView::addNew(QAction* action) {
 	WorksheetElement* aspect = nullptr;
 	if (action == addCartesianPlot1Action) {
 		CartesianPlot* plot = new CartesianPlot(i18n("xy-plot"));
 		plot->initDefault(CartesianPlot::FourAxes);
 		plot->setMouseMode(m_cartesianPlotMouseMode);
 		aspect = plot;
 		if (tbNewCartesianPlot)
 			tbNewCartesianPlot->setDefaultAction(addCartesianPlot1Action);
 	} else if (action == addCartesianPlot2Action) {
 		CartesianPlot* plot = new CartesianPlot(i18n("xy-plot"));
 		plot->initDefault(CartesianPlot::TwoAxes);
 		plot->setMouseMode(m_cartesianPlotMouseMode);
 		aspect = plot;
 		if (tbNewCartesianPlot)
 			tbNewCartesianPlot->setDefaultAction(addCartesianPlot2Action);
 	} else if (action == addCartesianPlot3Action) {
 		CartesianPlot* plot = new CartesianPlot(i18n("xy-plot"));
 		plot->initDefault(CartesianPlot::TwoAxesCentered);
 		plot->setMouseMode(m_cartesianPlotMouseMode);
 		aspect = plot;
 		if (tbNewCartesianPlot)
 			tbNewCartesianPlot->setDefaultAction(addCartesianPlot3Action);
 	} else if (action == addCartesianPlot4Action) {
 		CartesianPlot* plot = new CartesianPlot(i18n("xy-plot"));
 		plot->initDefault(CartesianPlot::TwoAxesCenteredZero);
 		plot->setMouseMode(m_cartesianPlotMouseMode);
 		aspect = plot;
 		if (tbNewCartesianPlot)
 			tbNewCartesianPlot->setDefaultAction(addCartesianPlot4Action);
 	} else if (action == addTextLabelAction) {
 		TextLabel* l = new TextLabel(i18n("Text Label"));
 		l->setText(i18n("Text Label"));
 		aspect = l;
 	} else if (action == addImageAction) {
 		Image* l = new Image(i18n("Image"));
 		aspect = l;
 	}
 	if (!aspect)
 		return;
 
 	m_worksheet->addChild(aspect);
 	handleCartesianPlotActions();
 
 	if (!m_fadeInTimeLine) {
 		m_fadeInTimeLine = new QTimeLine(1000, this);
 		m_fadeInTimeLine->setFrameRange(0, 100);
 		connect(m_fadeInTimeLine, &QTimeLine::valueChanged, this, &WorksheetView::fadeIn);
 	}
 
 	//if there is already an element fading in, stop the time line and show the element with the full opacity.
 	if (m_fadeInTimeLine->state() == QTimeLine::Running) {
 		m_fadeInTimeLine->stop();
 		auto* effect = new QGraphicsOpacityEffect();
 		effect->setOpacity(1);
 		lastAddedWorksheetElement->graphicsItem()->setGraphicsEffect(effect);
 	}
 
 	//fade-in the newly added element
 	lastAddedWorksheetElement = aspect;
 	auto* effect = new QGraphicsOpacityEffect();
 	effect->setOpacity(0);
 	lastAddedWorksheetElement->graphicsItem()->setGraphicsEffect(effect);
 	m_fadeInTimeLine->start();
 }
 
 /*!
  * select all top-level items
  */
 void WorksheetView::selectAllElements() {
 	//deselect all previously selected items since there can be some non top-level items belong them
 	m_suppressSelectionChangedEvent = true;
 	for (auto* item : m_selectedItems)
 		m_worksheet->setItemSelectedInView(item, false);
 
 	//select top-level items
 	for (auto* item : scene()->items()) {
 		if (!item->parentItem())
 			item->setSelected(true);
 	}
 	m_suppressSelectionChangedEvent = false;
 	this->selectionChanged();
 }
 
 /*!
  * deletes selected worksheet elements
  */
 void WorksheetView::deleteElement() {
 	if (m_selectedItems.isEmpty())
 		return;
 
 	int rc = KMessageBox::warningYesNo( this, i18np("Do you really want to delete the selected object?", "Do you really want to delete the selected %1 objects?", m_selectedItems.size()),
 				i18np("Delete selected object", "Delete selected objects", m_selectedItems.size()));
 
 	if (rc == KMessageBox::No)
 		return;
 
 	m_suppressSelectionChangedEvent = true;
 	m_worksheet->beginMacro(i18n("%1: Remove selected worksheet elements.", m_worksheet->name()));
 	for (auto* item : m_selectedItems)
 		m_worksheet->deleteAspectFromGraphicsItem(item);
 	m_worksheet->endMacro();
 	m_suppressSelectionChangedEvent = false;
 }
 
 void WorksheetView::aspectAboutToBeRemoved(const AbstractAspect* aspect) {
 	lastAddedWorksheetElement = dynamic_cast<WorksheetElement*>(const_cast<AbstractAspect*>(aspect));
 	if (!lastAddedWorksheetElement)
 		return;
 
 	//FIXME: fading-out doesn't work
 	//also, the following code collides with undo/redo of the deletion
 	//of a worksheet element (after redoing the element is not shown with the full opacity
 	/*
 		if (!m_fadeOutTimeLine) {
 			m_fadeOutTimeLine = new QTimeLine(1000, this);
 			m_fadeOutTimeLine->setFrameRange(0, 100);
 			connect(m_fadeOutTimeLine, SIGNAL(valueChanged(qreal)), this, SLOT(fadeOut(qreal)));
 		}
 
 		//if there is already an element fading out, stop the time line
 		if (m_fadeOutTimeLine->state() == QTimeLine::Running)
 			m_fadeOutTimeLine->stop();
 
 		m_fadeOutTimeLine->start();
 	*/
 }
 
 void WorksheetView::fadeIn(qreal value) {
 	auto* effect = new QGraphicsOpacityEffect();
 	effect->setOpacity(value);
 	lastAddedWorksheetElement->graphicsItem()->setGraphicsEffect(effect);
 }
 
 void WorksheetView::fadeOut(qreal value) {
 	auto* effect = new QGraphicsOpacityEffect();
 	effect->setOpacity(1 - value);
 	lastAddedWorksheetElement->graphicsItem()->setGraphicsEffect(effect);
 }
 
 /*!
  * called when one of the layout-actions in WorkseetView was triggered.
  * sets the layout in Worksheet and enables/disables the layout actions.
  */
 void WorksheetView::changeLayout(QAction* action) {
 	if (action == breakLayoutAction) {
 		verticalLayoutAction->setEnabled(true);
 		verticalLayoutAction->setChecked(false);
 
 		horizontalLayoutAction->setEnabled(true);
 		horizontalLayoutAction->setChecked(false);
 
 		gridLayoutAction->setEnabled(true);
 		gridLayoutAction->setChecked(false);
 
 		breakLayoutAction->setEnabled(false);
 
 		m_worksheet->setLayout(Worksheet::NoLayout);
 	} else {
 		verticalLayoutAction->setEnabled(false);
 		horizontalLayoutAction->setEnabled(false);
 		gridLayoutAction->setEnabled(false);
 		breakLayoutAction->setEnabled(true);
 
 		if (action == verticalLayoutAction) {
 			verticalLayoutAction->setChecked(true);
 			m_worksheet->setLayout(Worksheet::VerticalLayout);
 		} else if (action == horizontalLayoutAction) {
 			horizontalLayoutAction->setChecked(true);
 			m_worksheet->setLayout(Worksheet::HorizontalLayout);
 		} else {
 			gridLayoutAction->setChecked(true);
 			m_worksheet->setLayout(Worksheet::GridLayout);
 		}
 	}
 }
 
 void WorksheetView::changeGrid(QAction* action) {
 	if (action == noGridAction) {
 		m_gridSettings.style = WorksheetView::NoGrid;
 		snapToGridAction->setEnabled(false);
 	} else if (action == sparseLineGridAction) {
 		m_gridSettings.style = WorksheetView::LineGrid;
 		m_gridSettings.color = Qt::gray;
 		m_gridSettings.opacity = 0.7;
 		m_gridSettings.horizontalSpacing = 15;
 		m_gridSettings.verticalSpacing = 15;
 	} else if (action == denseLineGridAction) {
 		m_gridSettings.style = WorksheetView::LineGrid;
 		m_gridSettings.color = Qt::gray;
 		m_gridSettings.opacity = 0.7;
 		m_gridSettings.horizontalSpacing = 5;
 		m_gridSettings.verticalSpacing = 5;
 	} else if (action == denseDotGridAction) {
 		m_gridSettings.style = WorksheetView::DotGrid;
 		m_gridSettings.color = Qt::black;
 		m_gridSettings.opacity = 0.7;
 		m_gridSettings.horizontalSpacing = 5;
 		m_gridSettings.verticalSpacing = 5;
 	} else if (action == sparseDotGridAction) {
 		m_gridSettings.style = WorksheetView::DotGrid;
 		m_gridSettings.color = Qt::black;
 		m_gridSettings.opacity = 0.7;
 		m_gridSettings.horizontalSpacing = 15;
 		m_gridSettings.verticalSpacing = 15;
 	} else if (action == customGridAction) {
 		auto* dlg = new GridDialog(this);
 		if (dlg->exec() == QDialog::Accepted)
 			dlg->save(m_gridSettings);
 		else
 			return;
 	}
 
 	if (m_gridSettings.style == WorksheetView::NoGrid)
 		snapToGridAction->setEnabled(false);
 	else
 		snapToGridAction->setEnabled(true);
 
 	invalidateScene(sceneRect(), QGraphicsScene::BackgroundLayer);
 }
 
 //TODO
 void WorksheetView::changeSnapToGrid() {
 
 }
 
 /*!
  *  Selects the QGraphicsItem \c item in \c WorksheetView.
  * 	The selection in \c ProjectExplorer is forwarded to  \c Worksheet
  *  and is finally handled here.
  */
 void WorksheetView::selectItem(QGraphicsItem* item) {
 	m_suppressSelectionChangedEvent = true;
 	item->setSelected(true);
 	m_selectedItems<<item;
 	handleCartesianPlotActions();
 	m_suppressSelectionChangedEvent = false;
 }
 
 /*!
  *  Deselects the \c QGraphicsItem \c item in \c WorksheetView.
  * 	The deselection in \c ProjectExplorer is forwarded to \c Worksheet
  *  and is finally handled here.
  */
 void WorksheetView::deselectItem(QGraphicsItem* item) {
 	m_suppressSelectionChangedEvent = true;
 	item->setSelected(false);
 	m_selectedItems.removeOne(item);
 	handleCartesianPlotActions();
 	m_suppressSelectionChangedEvent = false;
 }
 
 /*!
  *  Called on selection changes in the view.
  *   Determines which items were selected and deselected
  *  and forwards these changes to \c Worksheet
  */
 void WorksheetView::selectionChanged() {
 	//if the project is being closed, the scene items are being removed and the selection can change.
 	//don't react on these changes since this can lead crashes (worksheet object is already in the destructor).
 	if (m_isClosing)
 		return;
 
 	if (m_suppressSelectionChangedEvent)
 		return;
 
 	QList<QGraphicsItem*> items = scene()->selectedItems();
 
 	//When making a graphics item invisible, it gets deselected in the scene.
 	//In this case we don't want to deselect the item in the project explorer.
 	bool invisibleDeselected = false;
 
 	//check, whether the previously selected items were deselected now.
 	//Forward the deselection prior to the selection of new items
 	//in order to avoid the unwanted multiple selection in project explorer
 	for (auto* item : m_selectedItems ) {
 		if ( items.indexOf(item) == -1 ) {
 			if (item->isVisible())
 				m_worksheet->setItemSelectedInView(item, false);
 			else
 				invisibleDeselected = true;
 		}
 	}
 
 	//select new items
 	if (items.isEmpty() && invisibleDeselected == false) {
 		//no items selected -> select the worksheet again.
 		m_worksheet->setSelectedInView(true);
 
 		//if one of the "zoom&select" plot mouse modes was selected before, activate the default "selection mode" again
 		//since no plots are selected now.
 		if (m_mouseMode == SelectionMode && m_cartesianPlotMouseMode!= CartesianPlot::SelectionMode) {
 			cartesianPlotSelectionModeAction->setChecked(true);
 			cartesianPlotMouseModeChanged(cartesianPlotSelectionModeAction);
 		}
 	} else {
 		for (const auto* item : items)
 			m_worksheet->setItemSelectedInView(item, true);
 
 		//items selected -> deselect the worksheet in the project explorer
 		//prevents unwanted multiple selection with worksheet (if it was selected before)
 		m_worksheet->setSelectedInView(false);
 	}
 
 	m_selectedItems = items;
 	handleCartesianPlotActions();
 }
 
 //check whether we have cartesian plots selected and activate/deactivate
 void WorksheetView::handleCartesianPlotActions() {
 	if (!m_menusInitialized)
 		return;
 
 	bool plot = false;
 	if (m_worksheet->cartesianPlotActionMode() == Worksheet::CartesianPlotActionMode::ApplyActionToSelection) {
 		//check whether we have cartesian plots selected
 		for (auto* item : m_selectedItems) {
 			//TODO: or if a children of a plot is selected
 			if (item->data(0).toInt() == WorksheetElement::NameCartesianPlot) {
 				plot = true;
 				break;
 			}
 		}
 	} else {
 		//actions are applied to all available plots -> check whether we have plots
 		plot = (m_worksheet->children<CartesianPlot>().size() != 0);
 	}
 
 	cartesianPlotSelectionModeAction->setEnabled(plot);
 	cartesianPlotZoomSelectionModeAction->setEnabled(plot);
 	cartesianPlotZoomXSelectionModeAction->setEnabled(plot);
 	cartesianPlotZoomYSelectionModeAction->setEnabled(plot);
 	cartesianPlotCursorModeAction->setEnabled(plot);
 
 	m_cartesianPlotAddNewMenu->setEnabled(plot);
 	m_cartesianPlotZoomMenu->setEnabled(plot);
 	m_cartesianPlotMouseModeMenu->setEnabled(plot);
 
 	// analysis menu
 	//TODO: enable also if children of plots are selected
 // 	m_dataManipulationMenu->setEnabled(plot);
 // 	addDataOperationAction->setEnabled(false);
 	addDataReductionAction->setEnabled(false);
 	addDifferentiationAction->setEnabled(plot);
 	addIntegrationAction->setEnabled(plot);
 	addInterpolationAction->setEnabled(plot);
 	addSmoothAction->setEnabled(plot);
 	addFitAction->setEnabled(plot);
 	addFourierFilterAction->setEnabled(plot);
 	addFourierTransformAction->setEnabled(plot);
 	addConvolutionAction->setEnabled(plot);
 	addCorrelationAction->setEnabled(plot);
 }
 
 void WorksheetView::exportToFile(const QString& path, const ExportFormat format, const ExportArea area, const bool background, const int resolution) {
 	QRectF sourceRect;
 
 	//determine the rectangular to print
 	if (area == WorksheetView::ExportBoundingBox)
 		sourceRect = scene()->itemsBoundingRect();
 	else if (area == WorksheetView::ExportSelection) {
 		//TODO doesn't work: rect = scene()->selectionArea().boundingRect();
 		for (const auto* item : m_selectedItems)
 			sourceRect = sourceRect.united( item->mapToScene(item->boundingRect()).boundingRect() );
 	} else
 		sourceRect = scene()->sceneRect();
 
 	//print
 	if (format == WorksheetView::Pdf) {
 		QPrinter printer(QPrinter::HighResolution);
 		printer.setOutputFormat(QPrinter::PdfFormat);
 
 		printer.setOutputFileName(path);
 		int w = Worksheet::convertFromSceneUnits(sourceRect.width(), Worksheet::Millimeter);
 		int h = Worksheet::convertFromSceneUnits(sourceRect.height(), Worksheet::Millimeter);
 		printer.setPaperSize( QSizeF(w, h), QPrinter::Millimeter);
 		printer.setPageMargins(0,0,0,0, QPrinter::Millimeter);
 		printer.setPrintRange(QPrinter::PageRange);
 		printer.setCreator(QLatin1String("LabPlot ") + LVERSION);
 
 		QPainter painter(&printer);
 		painter.setRenderHint(QPainter::Antialiasing);
 		QRectF targetRect(0, 0, painter.device()->width(),painter.device()->height());
 		painter.begin(&printer);
 		exportPaint(&painter, targetRect, sourceRect, background);
 		painter.end();
 	} else if (format == WorksheetView::Svg) {
 		QSvgGenerator generator;
 		generator.setFileName(path);
 		int w = Worksheet::convertFromSceneUnits(sourceRect.width(), Worksheet::Millimeter);
 		int h = Worksheet::convertFromSceneUnits(sourceRect.height(), Worksheet::Millimeter);
 		w = w*QApplication::desktop()->physicalDpiX()/25.4;
 		h = h*QApplication::desktop()->physicalDpiY()/25.4;
 
 		generator.setSize(QSize(w, h));
 		QRectF targetRect(0, 0, w, h);
 		generator.setViewBox(targetRect);
 
 		QPainter painter;
 		painter.begin(&generator);
 		exportPaint(&painter, targetRect, sourceRect, background);
 		painter.end();
 	} else {
 		//PNG
 		//TODO add all formats supported by Qt in QImage
 		int w = Worksheet::convertFromSceneUnits(sourceRect.width(), Worksheet::Millimeter);
 		int h = Worksheet::convertFromSceneUnits(sourceRect.height(), Worksheet::Millimeter);
 		w = w*resolution/25.4;
 		h = h*resolution/25.4;
 		QImage image(QSize(w, h), QImage::Format_ARGB32_Premultiplied);
 		image.fill(Qt::transparent);
 		QRectF targetRect(0, 0, w, h);
 
 		QPainter painter;
 		painter.begin(&image);
 		painter.setRenderHint(QPainter::Antialiasing);
 		exportPaint(&painter, targetRect, sourceRect, background);
 		painter.end();
 
 		if (!path.isEmpty())
 			image.save(path, "PNG");
 		else
 			QApplication::clipboard()->setImage(image, QClipboard::Clipboard);
 	}
 }
 
 void WorksheetView::exportToClipboard() {
 	QRectF sourceRect;
 
 	if (m_selectedItems.size() == 0)
 		sourceRect = scene()->itemsBoundingRect();
 	else {
 		//export selection
 		for (const auto* item : m_selectedItems)
 			sourceRect = sourceRect.united( item->mapToScene(item->boundingRect()).boundingRect() );
 	}
 
 	int w = Worksheet::convertFromSceneUnits(sourceRect.width(), Worksheet::Millimeter);
 	int h = Worksheet::convertFromSceneUnits(sourceRect.height(), Worksheet::Millimeter);
 	w = w*QApplication::desktop()->physicalDpiX()/25.4;
 	h = h*QApplication::desktop()->physicalDpiY()/25.4;
 	QImage image(QSize(w, h), QImage::Format_ARGB32_Premultiplied);
 	image.fill(Qt::transparent);
 	QRectF targetRect(0, 0, w, h);
 
 	QPainter painter;
 	painter.begin(&image);
 	painter.setRenderHint(QPainter::Antialiasing);
 	exportPaint(&painter, targetRect, sourceRect, true);
 	painter.end();
 
 	QApplication::clipboard()->setImage(image, QClipboard::Clipboard);
 }
 
 void WorksheetView::exportPaint(QPainter* painter, const QRectF& targetRect, const QRectF& sourceRect, const bool background) {
 	//draw the background
 	if (background) {
 		painter->save();
 		painter->scale(targetRect.width()/sourceRect.width(), targetRect.height()/sourceRect.height());
 		drawBackground(painter, sourceRect);
 		painter->restore();
 	}
 
 	//draw the scene items
 	m_worksheet->setPrinting(true);
 	scene()->render(painter, QRectF(), sourceRect);
 	m_worksheet->setPrinting(false);
 }
 
 void WorksheetView::print(QPrinter* printer) {
 	m_worksheet->setPrinting(true);
 	QPainter painter(printer);
 	painter.setRenderHint(QPainter::Antialiasing);
 
 	// draw background
 	QRectF page_rect = printer->pageRect();
 	QRectF scene_rect = scene()->sceneRect();
 	float scale = qMax(scene_rect.width()/page_rect.width(),scene_rect.height()/page_rect.height());
 	drawBackgroundItems(&painter, QRectF(0,0,scene_rect.width()/scale,scene_rect.height()/scale));
 
 	// draw scene
 	scene()->render(&painter);
 	m_worksheet->setPrinting(false);
 }
 
 void WorksheetView::updateBackground() {
 	invalidateScene(sceneRect(), QGraphicsScene::BackgroundLayer);
 }
 
 /*!
  * called when the layout was changed in Worksheet,
  * enables the corresponding action
  */
 void WorksheetView::layoutChanged(Worksheet::Layout layout) {
 	if (layout == Worksheet::NoLayout) {
 		verticalLayoutAction->setEnabled(true);
 		verticalLayoutAction->setChecked(false);
 
 		horizontalLayoutAction->setEnabled(true);
 		horizontalLayoutAction->setChecked(false);
 
 		gridLayoutAction->setEnabled(true);
 		gridLayoutAction->setChecked(false);
 
 		breakLayoutAction->setEnabled(false);
 	} else {
 		verticalLayoutAction->setEnabled(false);
 		horizontalLayoutAction->setEnabled(false);
 		gridLayoutAction->setEnabled(false);
 		breakLayoutAction->setEnabled(true);
 
 		if (layout == Worksheet::VerticalLayout)
 			verticalLayoutAction->setChecked(true);
 		else if (layout == Worksheet::HorizontalLayout)
 			horizontalLayoutAction->setChecked(true);
 		else
 			gridLayoutAction->setChecked(true);
 	}
 }
 
 void WorksheetView::registerShortcuts() {
 	selectAllAction->setShortcut(Qt::CTRL+Qt::Key_A);
 	deleteAction->setShortcut(Qt::Key_Delete);
 	backspaceAction->setShortcut(Qt::Key_Backspace);
 	zoomInViewAction->setShortcut(Qt::CTRL+Qt::Key_Plus);
 	zoomOutViewAction->setShortcut(Qt::CTRL+Qt::Key_Minus);
 	zoomOriginAction->setShortcut(Qt::CTRL+Qt::Key_1);
 }
 
 void WorksheetView::unregisterShortcuts() {
 	selectAllAction->setShortcut(QKeySequence());
 	deleteAction->setShortcut(QKeySequence());
 	backspaceAction->setShortcut(QKeySequence());
 	zoomInViewAction->setShortcut(QKeySequence());
 	zoomOutViewAction->setShortcut(QKeySequence());
 	zoomOriginAction->setShortcut(QKeySequence());
 }
 
 //##############################################################################
 //########################  SLOTs for cartesian plots   ########################
 //##############################################################################
 void WorksheetView::cartesianPlotActionModeChanged(QAction* action) {
 	if (action == cartesianPlotApplyToSelectionAction)
 		m_worksheet->setCartesianPlotActionMode(Worksheet::CartesianPlotActionMode::ApplyActionToSelection);
 	else
 		m_worksheet->setCartesianPlotActionMode(Worksheet::CartesianPlotActionMode::ApplyActionToAll);
 
 	handleCartesianPlotActions();
 }
 
 void WorksheetView::cartesianPlotCursorModeChanged(QAction* action) {
 	if (action == cartesianPlotApplyToSelectionCursor)
 		m_worksheet->setCartesianPlotCursorMode(Worksheet::CartesianPlotActionMode::ApplyActionToSelection);
 	else
 		m_worksheet->setCartesianPlotCursorMode(Worksheet::CartesianPlotActionMode::ApplyActionToAll);
 
 	handleCartesianPlotActions();
 }
 
 void WorksheetView::plotsLockedActionChanged(bool checked) {
 	m_worksheet->setPlotsLocked(checked);
 }
 
 void WorksheetView::cartesianPlotMouseModeChanged(QAction* action) {
 	if (m_suppressMouseModeChange)
 		return;
 
 	if (action == cartesianPlotSelectionModeAction)
 		m_cartesianPlotMouseMode = CartesianPlot::SelectionMode;
 	else if (action == cartesianPlotZoomSelectionModeAction)
 		m_cartesianPlotMouseMode = CartesianPlot::ZoomSelectionMode;
 	else if (action == cartesianPlotZoomXSelectionModeAction)
 		m_cartesianPlotMouseMode = CartesianPlot::ZoomXSelectionMode;
 	else if (action == cartesianPlotZoomYSelectionModeAction)
 		m_cartesianPlotMouseMode = CartesianPlot::ZoomYSelectionMode;
 	else if (action == cartesianPlotCursorModeAction)
 		m_cartesianPlotMouseMode = CartesianPlot::Cursor;
 
 	for (auto* plot : m_worksheet->children<CartesianPlot>() )
 		plot->setMouseMode(m_cartesianPlotMouseMode);
 }
 
 void WorksheetView::cartesianPlotMouseModeChangedSlot(CartesianPlot::MouseMode mouseMode) {
 	if (!m_menusInitialized)
 		return;
 
 	m_suppressMouseModeChange = true;
 	if (mouseMode == CartesianPlot::MouseMode::SelectionMode)
 		cartesianPlotSelectionModeAction->setChecked(true);
 	else if (mouseMode == CartesianPlot::MouseMode::ZoomSelectionMode)
 		cartesianPlotZoomSelectionModeAction->setChecked(true);
 	else if (mouseMode == CartesianPlot::MouseMode::ZoomXSelectionMode)
 		cartesianPlotZoomXSelectionModeAction->setChecked(true);
 	else if (mouseMode == CartesianPlot::MouseMode::ZoomYSelectionMode)
 		cartesianPlotZoomYSelectionModeAction->setChecked(true);
 	else if (mouseMode == CartesianPlot::MouseMode::Cursor)
 		cartesianPlotCursorModeAction->setChecked(true);
 	m_suppressMouseModeChange = false;
 }
 
 void WorksheetView::cartesianPlotAddNew(QAction* action) {
 	QVector<CartesianPlot*> plots = m_worksheet->children<CartesianPlot>();
 	if (m_worksheet->cartesianPlotActionMode() == Worksheet::ApplyActionToSelection) {
 		int selectedPlots = 0;
 		for (auto* plot : plots) {
 			if (m_selectedItems.indexOf(plot->graphicsItem()) != -1)
 				++selectedPlots;
 		}
 
 		if  (selectedPlots > 1)
 			m_worksheet->beginMacro(i18n("%1: Add curve to %2 plots", m_worksheet->name(), selectedPlots));
 
 		for (auto* plot : plots) {
 			//TODO: or if any children of a plot is selected
 			if (m_selectedItems.indexOf(plot->graphicsItem()) != -1)
 				this->cartesianPlotAdd(plot, action);
 		}
 
 		if (selectedPlots > 1)
 			m_worksheet->endMacro();
 	} else {
 		if  (plots.size() > 1)
 			m_worksheet->beginMacro(i18n("%1: Add curve to %2 plots", m_worksheet->name(), plots.size()));
 
 		for (auto* plot : plots)
 			this->cartesianPlotAdd(plot, action);
 
 		if  (plots.size() > 1)
 			m_worksheet->endMacro();
 	}
 }
 
 void WorksheetView::cartesianPlotAdd(CartesianPlot* plot, QAction* action) {
 	DEBUG("WorksheetView::cartesianPlotAdd()");
 	if (action == addCurveAction)
 		plot->addCurve();
 	else if (action == addHistogramAction)
 		plot->addHistogram();
 	else if (action == addEquationCurveAction)
 		plot->addEquationCurve();
 	else if (action == addDataReductionCurveAction)
 		plot->addDataReductionCurve();
 	else if (action == addDifferentiationCurveAction)
 		plot->addDifferentiationCurve();
 	else if (action == addIntegrationCurveAction)
 		plot->addIntegrationCurve();
 	else if (action == addInterpolationCurveAction)
 		plot->addInterpolationCurve();
 	else if (action == addSmoothCurveAction)
 		plot->addSmoothCurve();
 	else if (action == addFitCurveAction)
 		plot->addFitCurve();
 	else if (action == addFourierFilterCurveAction)
 		plot->addFourierFilterCurve();
 	else if (action == addFourierTransformCurveAction)
 		plot->addFourierTransformCurve();
 	else if (action == addConvolutionCurveAction)
 		plot->addConvolutionCurve();
 	else if (action == addCorrelationCurveAction)
 		plot->addCorrelationCurve();
 	else if (action == addLegendAction)
 		plot->addLegend();
 	else if (action == addHorizontalAxisAction)
 		plot->addHorizontalAxis();
 	else if (action == addVerticalAxisAction)
 		plot->addVerticalAxis();
 	else if (action == addPlotTextLabelAction)
 		plot->addTextLabel();
+	else if (action == addPlotImageAction)
+		plot->addImage();
 	else if (action == addCustomPointAction)
 		plot->addCustomPoint();
 // analysis actions
 	else if (action == addDataReductionAction)
 		plot->addDataReductionCurve();
 	else if (action == addDifferentiationAction)
 		plot->addDifferentiationCurve();
 	else if (action == addIntegrationAction)
 		plot->addIntegrationCurve();
 	else if (action == addInterpolationAction)
 		plot->addInterpolationCurve();
 	else if (action == addSmoothAction)
 		plot->addSmoothCurve();
 	else if (action == addFitAction)
 		plot->addFitCurve();
 	else if (action == addFourierFilterAction)
 		plot->addFourierFilterCurve();
 	else if (action == addFourierTransformAction)
 		plot->addFourierTransformCurve();
 	else if (action == addConvolutionAction)
 		plot->addConvolutionCurve();
 	else if (action == addCorrelationAction)
 		plot->addCorrelationCurve();
 }
 
 void WorksheetView::cartesianPlotNavigationChanged(QAction* action) {
 	CartesianPlot::NavigationOperation op = (CartesianPlot::NavigationOperation)action->data().toInt();
 	if (m_worksheet->cartesianPlotActionMode() == Worksheet::ApplyActionToSelection) {
 		for (auto* plot : m_worksheet->children<CartesianPlot>() ) {
 			if (m_selectedItems.indexOf(plot->graphicsItem()) != -1)
 				plot->navigate(op);
 			else {
 				// check if one of the plots childrend is selected. Do the operation there too.
 				for (auto* child : plot->children<WorksheetElement>()) {
 					if (m_selectedItems.indexOf(child->graphicsItem()) != -1) {
 						plot->navigate(op);
 						break;
 					}
 				}
 			}
 		}
 	} else {
 		for (auto* plot : m_worksheet->children<CartesianPlot>() )
 			plot->navigate(op);
 	}
 }
 
 Worksheet::CartesianPlotActionMode WorksheetView::getCartesianPlotActionMode() {
 	return m_worksheet->cartesianPlotActionMode();
 }
 
 void WorksheetView::presenterMode() {
 	KConfigGroup group = KSharedConfig::openConfig()->group("Settings_Worksheet");
 
 	//show dynamic presenter widget, if enabled
 	if (group.readEntry("PresenterModeInteractive", false)) {
 		auto* dynamicPresenterWidget = new DynamicPresenterWidget(m_worksheet);
 		dynamicPresenterWidget->showFullScreen();
 		return;
 	}
 
 	//show static presenter widget (default)
 	QRectF sourceRect(scene()->sceneRect());
 
 	int w = Worksheet::convertFromSceneUnits(sourceRect.width(), Worksheet::Millimeter);
 	int h = Worksheet::convertFromSceneUnits(sourceRect.height(), Worksheet::Millimeter);
 	w *= QApplication::desktop()->physicalDpiX()/25.4;
 	h *= QApplication::desktop()->physicalDpiY()/25.4;
 
 	QRectF targetRect(0, 0, w, h);
 	const QRectF& screenSize = QGuiApplication::primaryScreen()->availableGeometry();;
 
 	if (targetRect.width() > screenSize.width() || ((targetRect.height() > screenSize.height()))) {
 		const double ratio = qMin(screenSize.width() / targetRect.width(), screenSize.height() / targetRect.height());
 		targetRect.setWidth(targetRect.width()* ratio);
 		targetRect.setHeight(targetRect.height() * ratio);
 	}
 
 	QImage image(QSize(targetRect.width(), targetRect.height()), QImage::Format_ARGB32_Premultiplied);
 	image.fill(Qt::transparent);
 	QPainter painter;
 	painter.begin(&image);
 	painter.setRenderHint(QPainter::Antialiasing);
 	exportPaint(&painter, targetRect, sourceRect, true);
 	painter.end();
 
 	PresenterWidget* presenterWidget = new PresenterWidget(QPixmap::fromImage(image), m_worksheet->name());
 	presenterWidget->showFullScreen();
 }
diff --git a/src/commonfrontend/worksheet/WorksheetView.h b/src/commonfrontend/worksheet/WorksheetView.h
index 3122d31b3..f1bf7b956 100644
--- a/src/commonfrontend/worksheet/WorksheetView.h
+++ b/src/commonfrontend/worksheet/WorksheetView.h
@@ -1,312 +1,313 @@
 /***************************************************************************
     File                 : WorksheetView.h
     Project              : LabPlot
     Description          : Worksheet view
     --------------------------------------------------------------------
     Copyright            : (C) 2009-2019 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2018 by Stefan Gerlach (stefan.gerlach@uni.kn)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef WORKSHEETVIEW_H
 #define WORKSHEETVIEW_H
 
 #include <QGraphicsView>
 #include "backend/worksheet/Worksheet.h"
 #include "backend/worksheet/plots/cartesian/CartesianPlot.h"
 
 class QPrinter;
 class QMenu;
 class QToolBar;
 class QToolButton;
 class QWheelEvent;
 class QTimeLine;
 
 class AbstractAspect;
 class WorksheetElement;
 
 #ifdef Q_OS_MAC
 	class KDMacTouchBar;
 #endif
 
 class WorksheetView : public QGraphicsView {
 	Q_OBJECT
 
 public:
 	explicit WorksheetView(Worksheet* worksheet);
 
 	enum ExportFormat {Pdf, Svg, Png};
 	enum GridStyle {NoGrid, LineGrid, DotGrid};
 	enum ExportArea {ExportBoundingBox, ExportSelection, ExportWorksheet};
 
 	struct GridSettings {
 		GridStyle style;
 		QColor color;
 		int horizontalSpacing;
 		int verticalSpacing;
 		double opacity;
 	};
 
 	enum MouseMode {SelectionMode, NavigationMode, ZoomSelectionMode};
 
 	void setScene(QGraphicsScene*);
 	void exportToFile(const QString&, const ExportFormat, const ExportArea, const bool, const int);
 	void exportToClipboard(const ExportFormat, const ExportArea, const bool, const int);
 	void exportToClipboard();
 	void setIsClosing();
 	void setIsBeingPresented(bool presenting);
 	void setCartesianPlotActionMode(Worksheet::CartesianPlotActionMode mode);
 	void setCartesianPlotCursorMode(Worksheet::CartesianPlotActionMode mode);
 	void setPlotLock(bool lock);
 
 	Worksheet::CartesianPlotActionMode getCartesianPlotActionMode();
 	void registerShortcuts();
 	void unregisterShortcuts();
 
 private:
 	void initBasicActions();
 	void initActions();
 	void initMenus();
 	void processResize();
 	void drawForeground(QPainter*, const QRectF&) override;
 	void drawBackground(QPainter*, const QRectF&) override;
 	void drawBackgroundItems(QPainter*, const QRectF&);
 	bool isPlotAtPos(QPoint) const;
 	CartesianPlot* plotAt(QPoint) const;
 	void exportPaint(QPainter* painter, const QRectF& targetRect, const QRectF& sourceRect, const bool);
 	void cartesianPlotAdd(CartesianPlot*, QAction*);
 
 	//events
 	void resizeEvent(QResizeEvent*) override;
 	void contextMenuEvent(QContextMenuEvent*) override;
 	void wheelEvent(QWheelEvent*) override;
 	void mousePressEvent(QMouseEvent*) override;
 	void mouseReleaseEvent(QMouseEvent*) override;
 	void mouseMoveEvent(QMouseEvent*) override;
 	void keyPressEvent(QKeyEvent*) override;
 	void keyReleaseEvent(QKeyEvent*) override;
 	void dragEnterEvent(QDragEnterEvent*) override;
 	void dragMoveEvent(QDragMoveEvent*) override;
 	void dropEvent(QDropEvent*) override;
 
 	Worksheet* m_worksheet;
 	MouseMode m_mouseMode{SelectionMode};
 	CartesianPlot::MouseMode m_cartesianPlotMouseMode{CartesianPlot::SelectionMode};
 	bool m_selectionBandIsShown{false};
 	QPoint m_selectionStart;
 	QPoint m_selectionEnd;
 	int magnificationFactor{0};
 	QGraphicsPixmapItem* m_magnificationWindow{nullptr};
 	GridSettings m_gridSettings;
 	QList<QGraphicsItem*> m_selectedItems;
 	bool m_suppressSelectionChangedEvent{false};
 	WorksheetElement* lastAddedWorksheetElement{nullptr};
 	QTimeLine* m_fadeInTimeLine{nullptr};
 	QTimeLine* m_fadeOutTimeLine{nullptr};
 	bool m_isClosing{false};
 	bool m_actionsInitialized{false};
 	bool m_menusInitialized{false};
 	int m_numScheduledScalings{0};
 	bool m_suppressMouseModeChange{false};
 
 	//Menus
 	QMenu* m_addNewMenu{nullptr};
 	QMenu* m_addNewCartesianPlotMenu{nullptr};
 	QMenu* m_zoomMenu{nullptr};
 	QMenu* m_magnificationMenu{nullptr};
 	QMenu* m_layoutMenu{nullptr};
 	QMenu* m_gridMenu{nullptr};
 	QMenu* m_themeMenu{nullptr};
 	QMenu* m_viewMouseModeMenu{nullptr};
 	QMenu* m_cartesianPlotMenu{nullptr};
 	QMenu* m_cartesianPlotMouseModeMenu{nullptr};
 	QMenu* m_cartesianPlotAddNewMenu{nullptr};
 	QMenu* m_cartesianPlotAddNewAnalysisMenu{nullptr};
 	QMenu* m_cartesianPlotZoomMenu{nullptr};
 	QMenu* m_cartesianPlotActionModeMenu{nullptr};
 	QMenu* m_cartesianPlotCursorModeMenu{nullptr};
 	QMenu* m_dataManipulationMenu{nullptr};
 
 	QToolButton* tbNewCartesianPlot{nullptr};
 	QToolButton* tbZoom{nullptr};
 	QToolButton* tbMagnification{nullptr};
 	QAction* currentZoomAction{nullptr};
 	QAction* currentMagnificationAction{nullptr};
 
 	//Actions
 	QAction* selectAllAction{nullptr};
 	QAction* deleteAction{nullptr};
 	QAction* backspaceAction{nullptr};
 
 	QAction* zoomInViewAction{nullptr};
 	QAction* zoomOutViewAction{nullptr};
 	QAction* zoomOriginAction{nullptr};
 	QAction* zoomFitPageHeightAction{nullptr};
 	QAction* zoomFitPageWidthAction{nullptr};
 	QAction* zoomFitSelectionAction{nullptr};
 
 	QAction* navigationModeAction{nullptr};
 	QAction* zoomSelectionModeAction{nullptr};
 	QAction* selectionModeAction{nullptr};
 
 	QAction* addCartesianPlot1Action{nullptr};
 	QAction* addCartesianPlot2Action{nullptr};
 	QAction* addCartesianPlot3Action{nullptr};
 	QAction* addCartesianPlot4Action{nullptr};
 	QAction* addTextLabelAction{nullptr};
 	QAction* addImageAction{nullptr};
 	QAction* addHistogram{nullptr};
 
 	QAction* verticalLayoutAction{nullptr};
 	QAction* horizontalLayoutAction{nullptr};
 	QAction* gridLayoutAction{nullptr};
 	QAction* breakLayoutAction{nullptr};
 
 	QAction* noGridAction{nullptr};
 	QAction* denseLineGridAction{nullptr};
 	QAction* sparseLineGridAction{nullptr};
 	QAction* denseDotGridAction{nullptr};
 	QAction* sparseDotGridAction{nullptr};
 	QAction* customGridAction{nullptr};
 	QAction* snapToGridAction{nullptr};
 
 	QAction* noMagnificationAction{nullptr};
 	QAction* twoTimesMagnificationAction{nullptr};
 	QAction* threeTimesMagnificationAction{nullptr};
 	QAction* fourTimesMagnificationAction{nullptr};
 	QAction* fiveTimesMagnificationAction{nullptr};
 
 	QAction* plotsLockedAction{nullptr};
 	QAction* showPresenterMode{nullptr};
 
 	//Actions for cartesian plots
 	QAction* cartesianPlotApplyToSelectionAction{nullptr};
 	QAction* cartesianPlotApplyToAllAction{nullptr};
 	QAction* cartesianPlotApplyToAllCursor{nullptr};
 	QAction* cartesianPlotApplyToSelectionCursor{nullptr};
 	QAction* cartesianPlotSelectionModeAction{nullptr};
 	QAction* cartesianPlotZoomSelectionModeAction{nullptr};
 	QAction* cartesianPlotZoomXSelectionModeAction{nullptr};
 	QAction* cartesianPlotZoomYSelectionModeAction{nullptr};
 	QAction* cartesianPlotCursorModeAction{nullptr};
 
 	QAction* addCurveAction{nullptr};
 	QAction* addHistogramAction{nullptr};
 	QAction* addEquationCurveAction{nullptr};
 	QAction* addDataOperationCurveAction{nullptr};
 	QAction* addDataReductionCurveAction{nullptr};
 	QAction* addDifferentiationCurveAction{nullptr};
 	QAction* addIntegrationCurveAction{nullptr};
 	QAction* addInterpolationCurveAction{nullptr};
 	QAction* addSmoothCurveAction{nullptr};
 	QAction* addFitCurveAction{nullptr};
 	QAction* addFourierFilterCurveAction{nullptr};
 	QAction* addFourierTransformCurveAction{nullptr};
 	QAction* addConvolutionCurveAction{nullptr};
 	QAction* addCorrelationCurveAction{nullptr};
 
 	QAction* addHorizontalAxisAction{nullptr};
 	QAction* addVerticalAxisAction{nullptr};
 	QAction* addLegendAction{nullptr};
 	QAction* addPlotTextLabelAction{nullptr};
+	QAction* addPlotImageAction{nullptr};
 	QAction* addCustomPointAction{nullptr};
 
 	QAction* scaleAutoXAction{nullptr};
 	QAction* scaleAutoYAction{nullptr};
 	QAction* scaleAutoAction{nullptr};
 	QAction* zoomInAction{nullptr};
 	QAction* zoomOutAction{nullptr};
 	QAction* zoomInXAction{nullptr};
 	QAction* zoomOutXAction{nullptr};
 	QAction* zoomInYAction{nullptr};
 	QAction* zoomOutYAction{nullptr};
 	QAction* shiftLeftXAction{nullptr};
 	QAction* shiftRightXAction{nullptr};
 	QAction* shiftUpYAction{nullptr};
 	QAction* shiftDownYAction{nullptr};
 
 	// Analysis menu
 	QAction* addDataOperationAction{nullptr};
 	QAction* addDataReductionAction{nullptr};
 	QAction* addDifferentiationAction{nullptr};
 	QAction* addIntegrationAction{nullptr};
 	QAction* addInterpolationAction{nullptr};
 	QAction* addSmoothAction{nullptr};
 	QAction* addFitAction{nullptr};
 	QAction* addFourierFilterAction{nullptr};
 	QAction* addFourierTransformAction{nullptr};
 	QAction* addConvolutionAction{nullptr};
 	QAction* addCorrelationAction{nullptr};
 
 public slots:
 	void createContextMenu(QMenu*);
 	void createAnalysisMenu(QMenu*);
 	void fillToolBar(QToolBar*);
 #ifdef Q_OS_MAC
 	void fillTouchBar(KDMacTouchBar*);
 #endif
 	void fillCartesianPlotToolBar(QToolBar*);
 	void print(QPrinter*);
 	void selectItem(QGraphicsItem*);
 	void presenterMode();
 	void cartesianPlotMouseModeChangedSlot(CartesianPlot::MouseMode mouseMode); // from cartesian Plot
 
 private slots:
 	void addNew(QAction*);
 	void aspectAboutToBeRemoved(const AbstractAspect*);
 	void selectAllElements();
 	void deleteElement();
 
 	void mouseModeChanged(QAction*);
 	void useViewSizeRequested();
 	void changeZoom(QAction*);
 	void magnificationChanged(QAction*);
 	void changeLayout(QAction*);
 	void changeGrid(QAction*);
 	void changeSnapToGrid();
 	void plotsLockedActionChanged(bool checked);
 
 	void deselectItem(QGraphicsItem*);
 	void selectionChanged();
 	void updateBackground();
 	void layoutChanged(Worksheet::Layout);
 
 	void fadeIn(qreal);
 	void fadeOut(qreal);
 
 	void zoom(int);
 	void scalingTime();
 	void animFinished();
 
 	//SLOTs for cartesian plots
 	void cartesianPlotActionModeChanged(QAction*);
 	void cartesianPlotCursorModeChanged(QAction*);
 	void cartesianPlotMouseModeChanged(QAction*);
 	void cartesianPlotNavigationChanged(QAction*);
 	void cartesianPlotAddNew(QAction*);
 	void handleCartesianPlotActions();
 
 signals:
 	void statusInfo(const QString&);
 };
 
 #endif