diff --git a/src/commonfrontend/datapicker/DatapickerImageView.cpp b/src/commonfrontend/datapicker/DatapickerImageView.cpp
index 3fbaa6499..58be97efa 100644
--- a/src/commonfrontend/datapicker/DatapickerImageView.cpp
+++ b/src/commonfrontend/datapicker/DatapickerImageView.cpp
@@ -1,825 +1,825 @@
 /***************************************************************************
     File                 : DatapickerImageView.cpp
     Project              : LabPlot
     Description          : DatapickerImage view for datapicker
     --------------------------------------------------------------------
     Copyright            : (C) 2015 by Ankit Wagadre (wagadre.ankit@gmail.com)
     Copyright            : (C) 2015-2016 by Alexander Semke (alexander.semke@web.de)
 
  ***************************************************************************/
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "commonfrontend/datapicker/DatapickerImageView.h"
 #include "backend/worksheet/Worksheet.h"
 #include "backend/datapicker/DatapickerPoint.h"
 #include "backend/datapicker/Datapicker.h"
 #include "backend/datapicker/Transform.h"
 #include "backend/datapicker/DatapickerCurve.h"
 #include "backend/datapicker/DatapickerImage.h"
 
 #include <limits>
 
 #include <QMenu>
 #include <QToolBar>
 #include <QDesktopWidget>
 #include <QWheelEvent>
 #include <QPrinter>
 #include <QSvgGenerator>
 #include <QImage>
 #include <QToolButton>
 #include <QTimeLine>
 
 #include <KLocalizedString>
 
 /**
  * \class DatapickerImageView
  * \brief Datapicker/DatapickerImage view
  */
 
 /*!
   Constructur of the class.
   Creates a view for the DatapickerImage \c image and initializes the internal model.
 */
 DatapickerImageView::DatapickerImageView(DatapickerImage* image) : QGraphicsView(),
 	m_image(image),
 	m_datapicker(dynamic_cast<Datapicker*>(m_image->parentAspect())),
 	m_transform(new Transform()) {
 
 	setScene(m_image->scene());
 
 	setRenderHint(QPainter::Antialiasing);
 	setRubberBandSelectionMode(Qt::ContainsItemBoundingRect);
 	setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
 	setResizeAnchor(QGraphicsView::AnchorViewCenter);
 	setMinimumSize(16, 16);
 	setFocusPolicy(Qt::StrongFocus);
 
 	viewport()->setAttribute( Qt::WA_OpaquePaintEvent );
 	viewport()->setAttribute( Qt::WA_NoSystemBackground );
 	setCacheMode(QGraphicsView::CacheBackground);
 
 	initActions();
 	initMenus();
 	selectAndEditModeAction->setChecked(true);
 	m_image->setSegmentsHoverEvent(true);
 	setInteractive(true);
 
 	changeZoom(zoomOriginAction);
 	currentZoomAction = zoomInViewAction;
 
 	if (m_image->plotPointsType() == DatapickerImage::AxisPoints)
 		setAxisPointsAction->setChecked(true);
 	else if (m_image->plotPointsType() == DatapickerImage::CurvePoints)
 		setCurvePointsAction->setChecked(true);
 	else
 		selectSegmentAction->setChecked(true);
 
 	handleImageActions();
 	changeRotationAngle();
 
 	//signal/slot connections
 	//for general actions
-	connect( m_image, SIGNAL(requestProjectContextMenu(QMenu*)), this, SLOT(createContextMenu(QMenu*)) );
-	connect( m_image, SIGNAL(requestUpdate()), this, SLOT(updateBackground()) );
-	connect( m_image, SIGNAL(requestUpdateActions()), this, SLOT(handleImageActions()) );
-	connect( m_datapicker, SIGNAL(requestUpdateActions()), this, SLOT(handleImageActions()) );
-	connect( m_image, SIGNAL(rotationAngleChanged(float)), this, SLOT(changeRotationAngle()) );
+	connect(m_image, &DatapickerImage::requestProjectContextMenu, this, &DatapickerImageView::createContextMenu);
+	connect(m_image, &DatapickerImage::requestUpdate, this, &DatapickerImageView::updateBackground);
+	connect(m_image, &DatapickerImage::requestUpdateActions, this, &DatapickerImageView::handleImageActions);
+	connect(m_datapicker, &Datapicker::requestUpdateActions, this, &DatapickerImageView::handleImageActions);
+	connect(m_image, &DatapickerImage::rotationAngleChanged, this, &DatapickerImageView::changeRotationAngle);
 
 	//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_image->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));
 }
 
 DatapickerImageView::~DatapickerImageView() {
 	delete m_transform;
 }
 
 void DatapickerImageView::initActions() {
 	auto* zoomActionGroup = new QActionGroup(this);
 	auto* mouseModeActionGroup = new QActionGroup(this);
 	auto* plotPointsTypeActionGroup = new QActionGroup(this);
 	navigationActionGroup = new QActionGroup(this);
 	magnificationActionGroup = new QActionGroup(this);
 
 	//Zoom actions
 	zoomInViewAction = new QAction(QIcon::fromTheme("zoom-in"), i18n("Zoom In"), zoomActionGroup);
 	zoomInViewAction->setShortcut(Qt::CTRL+Qt::Key_Plus);
 
 	zoomOutViewAction = new QAction(QIcon::fromTheme("zoom-out"), i18n("Zoom Out"), zoomActionGroup);
 	zoomOutViewAction->setShortcut(Qt::CTRL+Qt::Key_Minus);
 
 	zoomOriginAction = new QAction(QIcon::fromTheme("zoom-original"), i18n("Original Size"), zoomActionGroup);
 	zoomOriginAction->setShortcut(Qt::CTRL+Qt::Key_1);
 
 	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);
 
 	// Mouse mode actions
 	selectAndEditModeAction = new QAction(QIcon::fromTheme("labplot-cursor-arrow"), i18n("Select and Edit"), mouseModeActionGroup);
 	selectAndEditModeAction->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);
 
 	setAxisPointsAction = new QAction(QIcon::fromTheme("labplot-plot-axis-points"), i18n("Set Axis Points"), plotPointsTypeActionGroup);
 	setAxisPointsAction->setCheckable(true);
 
 	setCurvePointsAction = new QAction(QIcon::fromTheme("labplot-xy-curve-points"), i18n("Set Curve Points"), plotPointsTypeActionGroup);
 	setCurvePointsAction->setCheckable(true);
 
 	selectSegmentAction = new QAction(QIcon::fromTheme("labplot-xy-curve-segments"), i18n("Select Curve Segments"), plotPointsTypeActionGroup);
 	selectSegmentAction->setCheckable(true);
 
 	addCurveAction = new QAction(QIcon::fromTheme("labplot-xy-curve"), i18n("New Curve"), this);
 
 	shiftLeftAction = new QAction(QIcon::fromTheme("labplot-shift-left-x"), i18n("Shift Left"), navigationActionGroup);
 	shiftLeftAction->setShortcut(Qt::Key_Right);
 
 	shiftRightAction = new QAction(QIcon::fromTheme("labplot-shift-right-x"), i18n("Shift Right"), navigationActionGroup);
 	shiftRightAction->setShortcut(Qt::Key_Left);
 
 	shiftUpAction = new QAction(QIcon::fromTheme("labplot-shift-down-y"), i18n("Shift Up"), navigationActionGroup);
 	shiftUpAction->setShortcut(Qt::Key_Up);
 
 	shiftDownAction = new QAction(QIcon::fromTheme("labplot-shift-up-y"), i18n("Shift Down"), navigationActionGroup);
 	shiftDownAction->setShortcut(Qt::Key_Down);
 
 	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);
 
-	connect( mouseModeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(mouseModeChanged(QAction*)) );
-	connect( zoomActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(changeZoom(QAction*)) );
-	connect( plotPointsTypeActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(changePointsType(QAction*)) );
-	connect( addCurveAction, SIGNAL(triggered()), this, SLOT(addCurve()) );
-	connect( navigationActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(changeSelectedItemsPosition(QAction*)) );
-	connect( magnificationActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(magnificationChanged(QAction*)) );
+	connect(mouseModeActionGroup, &QActionGroup::triggered, this, &DatapickerImageView::mouseModeChanged);
+	connect(zoomActionGroup, &QActionGroup::triggered, this, &DatapickerImageView::changeZoom);
+	connect(plotPointsTypeActionGroup, &QActionGroup::triggered, this, &DatapickerImageView::changePointsType);
+	connect(addCurveAction, &QAction::triggered, this, &DatapickerImageView::addCurve);
+	connect(navigationActionGroup, &QActionGroup::triggered, this, &DatapickerImageView::changeSelectedItemsPosition);
+	connect(magnificationActionGroup, &QActionGroup::triggered, this, &DatapickerImageView::magnificationChanged);
 
 	//set some default values
 	currentZoomAction = zoomInViewAction;
 	currentMagnificationAction = noMagnificationAction;
 }
 
 void DatapickerImageView::initMenus() {
 	m_viewMouseModeMenu = new QMenu(i18n("Mouse Mode"), this);
 	m_viewMouseModeMenu->setIcon(QIcon::fromTheme("input-mouse"));
 	m_viewMouseModeMenu->addAction(selectAndEditModeAction);
 	m_viewMouseModeMenu->addAction(navigationModeAction);
 	m_viewMouseModeMenu->addAction(zoomSelectionModeAction);
 
 	m_viewImageMenu = new QMenu(i18n("Data Entry Mode"), this);
 	m_viewImageMenu->addAction(setAxisPointsAction);
 	m_viewImageMenu->addAction(setCurvePointsAction);
 	m_viewImageMenu->addAction(selectSegmentAction);
 
 	m_zoomMenu = new QMenu(i18n("Zoom View"), 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_navigationMenu = new QMenu(i18n("Move Last Point"), this);
 	m_navigationMenu->addAction(shiftLeftAction);
 	m_navigationMenu->addAction(shiftRightAction);
 	m_navigationMenu->addAction(shiftUpAction);
 	m_navigationMenu->addAction(shiftDownAction);
 
 	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);
 }
 
 /*!
  * Populates the menu \c menu with the image and image-view relevant actions.
  * The menu is used
  *   - as the context menu in DatapickerImageView
  *   - as the "datapicker menu" in the main menu-bar (called form MainWin)
  *   - as a part of the image context menu in project explorer
  */
 void DatapickerImageView::createContextMenu(QMenu* menu) const {
 	Q_ASSERT(menu);
 
 	QAction* firstAction = nullptr;
 	// if we're populating the context menu for the project explorer, then
 	//there're already actions available there. Skip the first title-action
 	//and insert the action at the beginning of the menu.
 	if (menu->actions().size()>1)
 		firstAction = menu->actions().at(1);
 
 	menu->insertMenu(firstAction, m_viewImageMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertAction(firstAction, addCurveAction);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, m_navigationMenu);
 	menu->insertSeparator(firstAction);
 	menu->insertMenu(firstAction, m_viewMouseModeMenu);
 	menu->insertMenu(firstAction, m_zoomMenu);
 	menu->insertMenu(firstAction, m_magnificationMenu);
 	menu->insertSeparator(firstAction);
 }
 
 void DatapickerImageView::fillToolBar(QToolBar* toolBar) {
 	toolBar->addSeparator();
 	toolBar->addAction(setAxisPointsAction);
 	toolBar->addAction(setCurvePointsAction);
 	toolBar->addAction(selectSegmentAction);
 
 	toolBar->addSeparator();
 	toolBar->addAction(addCurveAction);
 
 	toolBar->addSeparator();
 	toolBar->addAction(shiftRightAction);
 	toolBar->addAction(shiftLeftAction);
 	toolBar->addAction(shiftUpAction);
 	toolBar->addAction(shiftDownAction);
 
 	toolBar->addSeparator();
 	toolBar->addAction(selectAndEditModeAction);
 	toolBar->addAction(navigationModeAction);
 	toolBar->addAction(zoomSelectionModeAction);
 
 	tbZoom = new QToolButton(toolBar);
 	tbZoom->setPopupMode(QToolButton::MenuButtonPopup);
 	tbZoom->setMenu(m_zoomMenu);
 	tbZoom->setDefaultAction(currentZoomAction);
 	toolBar->addSeparator();
 	toolBar->addWidget(tbZoom);
 
 	tbMagnification = new QToolButton(toolBar);
 	tbMagnification->setPopupMode(QToolButton::MenuButtonPopup);
 	tbMagnification->setMenu(m_magnificationMenu);
 	tbMagnification->setDefaultAction(currentMagnificationAction);
 	toolBar->addWidget(tbMagnification);
 }
 
 void DatapickerImageView::setScene(QGraphicsScene* scene) {
 	QGraphicsView::setScene(scene);
 	setTransform(QTransform());
 }
 
 void DatapickerImageView::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();
 		painter->setPen(QPen(Qt::black, 5/transform().m11()));
 		painter->drawRect(selRect);
 		painter->setBrush(Qt::blue);
 		painter->setOpacity(0.2);
 		painter->drawRect(selRect);
 		painter->restore();
 	}
 	QGraphicsView::drawForeground(painter, rect);
 }
 
 void DatapickerImageView::drawBackground(QPainter* painter, const QRectF& rect) {
 	painter->save();
 
 	QRectF scene_rect = sceneRect();
 	if (!scene_rect.contains(rect))
 		painter->fillRect(rect, Qt::lightGray);
 
 	// canvas
 	if (m_image->isLoaded) {
 		if (m_image->plotImageType() == DatapickerImage::OriginalImage) {
 			QImage todraw = m_image->originalPlotImage.scaled(scene_rect.width(), scene_rect.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 			painter->drawImage(scene_rect.topLeft(), todraw);
 		} else if (m_image->plotImageType() == DatapickerImage::ProcessedImage) {
 			QImage todraw = m_image->processedPlotImage.scaled(scene_rect.width(), scene_rect.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 			painter->drawImage(scene_rect.topLeft(), todraw);
 		} else {
 			painter->fillRect(scene_rect, Qt::white);
 		}
 	} else {
 		painter->setBrush(QBrush(Qt::gray));
 		painter->drawRect(scene_rect);
 	}
 
 	invalidateScene(rect, QGraphicsScene::BackgroundLayer);
 	painter->restore();
 }
 
 //##############################################################################
 //####################################  Events   ###############################
 //##############################################################################
 void DatapickerImageView::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 DatapickerImageView::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, &DatapickerImageView::scalingTime);
 	connect(anim, &QTimeLine::finished, this, &DatapickerImageView::animFinished);
 	anim->start();
 }
 
 void DatapickerImageView::scalingTime() {
 	qreal factor = 1.0 + qreal(m_numScheduledScalings) / 300.0;
 	scale(factor, factor);
 }
 
 void DatapickerImageView::animFinished() {
 	if (m_numScheduledScalings > 0)
 		m_numScheduledScalings--;
 	else
 		m_numScheduledScalings++;
 	sender()->~QObject();
 }
 
 void DatapickerImageView::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_selectionBandIsShown = true;
 		return;
 	}
 
 	QPointF eventPos = mapToScene(event->pos());
 	if ( m_mouseMode == SelectAndEditMode && m_image->isLoaded && sceneRect().contains(eventPos) ) {
 		if ( m_image->plotPointsType() == DatapickerImage::AxisPoints ) {
 			int childCount = m_image->childCount<DatapickerPoint>(AbstractAspect::IncludeHidden);
 			if (childCount < 3)
 				m_datapicker->addNewPoint(eventPos, m_image);
 		} else if ( m_image->plotPointsType() == DatapickerImage::CurvePoints && m_datapicker->activeCurve() ) {
 			m_datapicker->addNewPoint(eventPos, m_datapicker->activeCurve());
 		}
 	}
 
 	// make sure the datapicker (or its currently active curve) is selected in the project explorer if the view was clicked.
 	// We need this for the case when we change from the project-node in the project explorer to the datapicker node by clicking the view.
 	if (m_datapicker->activeCurve() && m_image->plotPointsType() != DatapickerImage::AxisPoints) {
 		m_datapicker->setSelectedInView(false);
 		m_datapicker->activeCurve()->setSelectedInView(true);
 	} else {
 		if (m_datapicker->activeCurve())
 			m_datapicker->activeCurve()->setSelectedInView(false);
 		m_datapicker->setSelectedInView(true);
 	}
 
 	QGraphicsView::mousePressEvent(event);
 }
 
 void DatapickerImageView::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 DatapickerImageView::mouseMoveEvent(QMouseEvent* event) {
 	if ( m_mouseMode == SelectAndEditMode || m_mouseMode == ZoomSelectionMode ) {
 		if (m_image->isLoaded)
 			setCursor(Qt::CrossCursor);
 		else
 			setCursor(Qt::ArrowCursor);
 	} else {
 		setCursor(Qt::ArrowCursor);
 	}
 
 	//show the selection band
 	if (m_selectionBandIsShown) {
 		QRect rect = QRect(m_selectionStart, m_selectionEnd).normalized();
 		m_selectionEnd = event->pos();
 		rect = rect.united(QRect(m_selectionStart, m_selectionEnd).normalized());
 		int 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);
 		return;
 	}
 
 	QPointF pos = mapToScene(event->pos());
 
 	//show the current coordinates under the mouse cursor in the status bar
 	if (m_image->plotPointsType() == DatapickerImage::CurvePoints) {
 		QVector3D logicalPos = m_transform->mapSceneToLogical(pos, m_image->axisPoints());
 		if (m_image->axisPoints().type == DatapickerImage::Ternary) {
 			emit statusInfo( "a =" + QString::number(logicalPos.x()) + ", b =" + QString::number(logicalPos.y()) + ", c =" + QString::number(logicalPos.z()));
 		} else {
 			QString xLabel('x');
 			QString yLabel('y');
 			if (m_image->axisPoints().type == DatapickerImage::PolarInDegree) {
 				xLabel = 'r';
 				yLabel = "y(deg)";
 			} else if (m_image->axisPoints().type == DatapickerImage::PolarInRadians) {
 				xLabel = 'r';
 				yLabel = "y(rad)";
 			}
 
 			if (m_datapicker->activeCurve()) {
 				QString statusText = i18n("%1, active curve \"%2\": %3=%4, %5=%6", m_datapicker->name(), m_datapicker->activeCurve()->name(), xLabel, QString::number(logicalPos.x()), yLabel, QString::number(logicalPos.y()));
 				emit statusInfo(statusText);
 			}
 		}
 	}
 
 	//show the magnification window
 	if ( magnificationFactor && m_mouseMode == SelectAndEditMode && m_image->isLoaded && sceneRect().contains(pos)
 		&& m_image->plotPointsType() != DatapickerImage::SegmentPoints ) {
 
 		if (!m_image->m_magnificationWindow) {
 //            m_image->m_magnificationWindow = new QGraphicsPixmapItem(0, scene());
 			m_image->m_magnificationWindow = new QGraphicsPixmapItem;
 			scene()->addItem(m_image->m_magnificationWindow);
 			m_image->m_magnificationWindow->setZValue(std::numeric_limits<int>::max());
 		}
 
 		m_image->m_magnificationWindow->setVisible(false);
 
 		//copy the part of the view to be shown magnified
 		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_image->m_magnificationWindow->setPixmap(px);
 		m_image->m_magnificationWindow->setPos(pos.x()- px.width()/2, pos.y()- px.height()/2);
 
 		m_image->m_magnificationWindow->setVisible(true);
 	} else if (m_image->m_magnificationWindow) {
 		m_image->m_magnificationWindow->setVisible(false);
 	}
 
 	QGraphicsView::mouseMoveEvent(event);
 }
 
 void DatapickerImageView::contextMenuEvent(QContextMenuEvent* e) {
 	Q_UNUSED(e);
 	//no need to propagate the event to the scene and graphics items
 	QMenu *menu = new QMenu(this);
 	this->createContextMenu(menu);
 	menu->exec(QCursor::pos());
 }
 
 //##############################################################################
 //####################################  SLOTs   ###############################
 //##############################################################################
 void DatapickerImageView::changePointsType(QAction* action) {
 	if (action == setAxisPointsAction)
 		m_image->setPlotPointsType(DatapickerImage::AxisPoints);
 	else if (action == setCurvePointsAction)
 		m_image->setPlotPointsType(DatapickerImage::CurvePoints);
 	else if (action == selectSegmentAction)
 		m_image->setPlotPointsType(DatapickerImage::SegmentPoints);
 }
 
 void DatapickerImageView::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()/(25.4*Worksheet::convertToSceneUnits(1,Worksheet::Millimeter));
 		static const float vscale = QApplication::desktop()->physicalDpiY()/(25.4*Worksheet::convertToSceneUnits(1,Worksheet::Millimeter));
 		setTransform(QTransform::fromScale(hscale, vscale));
 		m_rotationAngle = 0;
 	} else if (action == zoomFitPageWidthAction) {
 		float scaleFactor = viewport()->width()/scene()->sceneRect().width();
 		setTransform(QTransform::fromScale(scaleFactor, scaleFactor));
 		m_rotationAngle = 0;
 	} else if (action == zoomFitPageHeightAction) {
 		float scaleFactor = viewport()->height()/scene()->sceneRect().height();
 		setTransform(QTransform::fromScale(scaleFactor, scaleFactor));
 		m_rotationAngle = 0;
 	}
 
 	currentZoomAction = action;
 	if (tbZoom)
 		tbZoom->setDefaultAction(action);
 
 	//change and set angle if tranform reset
 	changeRotationAngle();
 }
 
 void DatapickerImageView::changeSelectedItemsPosition(QAction* action) {
 	if (scene()->selectedItems().isEmpty())
 		return;
 
 	QPointF shift(0, 0);
 	if (action == shiftLeftAction)
 		shift.setX(1);
 	else if (action == shiftRightAction)
 		shift.setX(-1);
 	else if (action == shiftUpAction)
 		shift.setY(-1);
 	else if (action == shiftDownAction)
 		shift.setY(1);
 
 	m_image->beginMacro(i18n("%1: change position of selected DatapickerPoints.", m_image->name()));
 	const QVector<DatapickerPoint*> axisPoints = m_image->children<DatapickerPoint>(AbstractAspect::IncludeHidden);
 	for (auto* point : axisPoints) {
 		if (!point->graphicsItem()->isSelected())
 			continue;
 
 		QPointF newPos = point->position();
 		newPos = newPos + shift;
 		point->setPosition(newPos);
 
 		int pointIndex = m_image->indexOfChild<DatapickerPoint>(point, AbstractAspect::IncludeHidden);
 		if (pointIndex == -1) continue;
 		DatapickerImage::ReferencePoints points = m_image->axisPoints();
 		points.scenePos[pointIndex].setX(point->position().x());
 		points.scenePos[pointIndex].setY(point->position().y());
 		m_image->setUndoAware(false);
 		m_image->setAxisPoints(points);
 		m_image->setUndoAware(true);
 	}
 
 	for (auto* curve : m_image->parentAspect()->children<DatapickerCurve>()) {
 		for (auto* point : curve->children<DatapickerPoint>(AbstractAspect::IncludeHidden)) {
 			if (!point->graphicsItem()->isSelected())
 				continue;
 
 			QPointF newPos = point->position();
 			newPos = newPos + shift;
 			point->setPosition(newPos);
 		}
 	}
 
 	m_image->endMacro();
 }
 
 void DatapickerImageView::mouseModeChanged(QAction* action) {
 	if (action == selectAndEditModeAction) {
 		m_mouseMode = SelectAndEditMode;
 		setInteractive(true);
 		setDragMode(QGraphicsView::NoDrag);
 		m_image->setSegmentsHoverEvent(true);
 	} else if (action == navigationModeAction) {
 		m_mouseMode = NavigationMode;
 		setInteractive(false);
 		setDragMode(QGraphicsView::ScrollHandDrag);
 		m_image->setSegmentsHoverEvent(false);
 	} else {
 		m_mouseMode = ZoomSelectionMode;
 		setInteractive(false);
 		setDragMode(QGraphicsView::NoDrag);
 		m_image->setSegmentsHoverEvent(false);
 	}
 }
 
 void DatapickerImageView::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;
 }
 
 void DatapickerImageView::addCurve() {
 	m_datapicker->beginMacro(i18n("%1: add new curve.", m_datapicker->name()));
 	DatapickerCurve* curve = new DatapickerCurve(i18n("Curve"));
 	curve->addDatasheet(m_image->axisPoints().type);
 	m_datapicker->addChild(curve);
 	m_datapicker->endMacro();
 }
 
 void DatapickerImageView::changeRotationAngle() {
 	this->rotate(m_rotationAngle);
 	this->rotate(-m_image->rotationAngle());
 	m_rotationAngle = m_image->rotationAngle();
 	updateBackground();
 }
 
 void DatapickerImageView::handleImageActions() {
 	if (m_image->isLoaded) {
 		magnificationActionGroup->setEnabled(true);
 		setAxisPointsAction->setEnabled(true);
 
 		int pointsCount = m_image->childCount<DatapickerPoint>(AbstractAspect::IncludeHidden);
 		if (pointsCount > 0)
 			navigationActionGroup->setEnabled(true);
 		else
 			navigationActionGroup->setEnabled(false);
 
 		if (pointsCount > 2) {
 			addCurveAction->setEnabled(true);
 			if (m_datapicker->activeCurve()) {
 				setCurvePointsAction->setEnabled(true);
 				selectSegmentAction->setEnabled(true);
 			} else {
 				setCurvePointsAction->setEnabled(false);
 				selectSegmentAction->setEnabled(false);
 			}
 		} else {
 			addCurveAction->setEnabled(false);
 			setCurvePointsAction->setEnabled(false);
 			selectSegmentAction->setEnabled(false);
 			if (m_image->plotPointsType() != DatapickerImage::AxisPoints) {
 				m_image->setUndoAware(false);
 				m_image->setPlotPointsType(DatapickerImage::AxisPoints);
 				m_image->setUndoAware(true);
 			}
 		}
 	} else {
 		navigationActionGroup->setEnabled(false);
 		magnificationActionGroup->setEnabled(false);
 		setAxisPointsAction->setEnabled(false);
 		addCurveAction->setEnabled(false);
 		setCurvePointsAction->setEnabled(false);
 		selectSegmentAction->setEnabled(false);
 	}
 }
 
 void DatapickerImageView::exportToFile(const QString& path, const WorksheetView::ExportFormat format, const int resolution) {
 	QRectF sourceRect;
 	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);
 		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);
 		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);
 		painter.end();
 
 		image.save(path, "png");
 	}
 }
 
 void DatapickerImageView::exportPaint(QPainter* painter, const QRectF& targetRect, const QRectF& sourceRect) {
 	painter->save();
 	painter->scale(targetRect.width()/sourceRect.width(), targetRect.height()/sourceRect.height());
 	drawBackground(painter, sourceRect);
 	painter->restore();
 	m_image->setPrinting(true);
 	scene()->render(painter, QRectF(), sourceRect);
 	m_image->setPrinting(false);
 }
 
 void DatapickerImageView::print(QPrinter* printer) {
 	const QRectF scene_rect = sceneRect();
 	int w = Worksheet::convertFromSceneUnits(scene_rect.width(), Worksheet::Millimeter);
 	int h = Worksheet::convertFromSceneUnits(scene_rect.height(), Worksheet::Millimeter);
 	printer->setPaperSize( QSizeF(w, h), QPrinter::Millimeter);
 	printer->setPageMargins(0,0,0,0, QPrinter::Millimeter);
 	printer->setPrintRange(QPrinter::PageRange);
 	printer->setCreator( QString("LabPlot ") + LVERSION );
 
 	QPainter painter(printer);
 	QRectF targetRect(0, 0, painter.device()->width(),painter.device()->height());
 	painter.setRenderHint(QPainter::Antialiasing);
 	painter.begin(printer);
 	painter.save();
 	painter.scale(targetRect.width()/scene_rect.width(), targetRect.height()/scene_rect.height());
 
 	// canvas
 	if (m_image->isLoaded) {
 		if (m_image->plotImageType() == DatapickerImage::OriginalImage) {
 			QImage todraw = m_image->originalPlotImage.scaled(scene_rect.width(), scene_rect.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 			painter.drawImage(scene_rect.topLeft(), todraw);
 		} else if (m_image->plotImageType() == DatapickerImage::ProcessedImage) {
 			QImage todraw = m_image->processedPlotImage.scaled(scene_rect.width(), scene_rect.height(), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 			painter.drawImage(scene_rect.topLeft(), todraw);
 		} else {
 			painter.fillRect(scene_rect, Qt::white);
 		}
 	} else {
 		painter.setBrush(QBrush(Qt::gray));
 		painter.drawRect(scene_rect);
 	}
 
 	painter.restore();
 	m_image->setPrinting(true);
 	scene()->render(&painter, QRectF(), scene_rect);
 	m_image->setPrinting(false);
 	painter.end();
 }
 
 void DatapickerImageView::updateBackground() {
 	invalidateScene(sceneRect(), QGraphicsScene::BackgroundLayer);
 }
diff --git a/src/kdefrontend/dockwidgets/ColumnDock.cpp b/src/kdefrontend/dockwidgets/ColumnDock.cpp
index bb0c3cd24..c25ee2179 100644
--- a/src/kdefrontend/dockwidgets/ColumnDock.cpp
+++ b/src/kdefrontend/dockwidgets/ColumnDock.cpp
@@ -1,424 +1,426 @@
 /***************************************************************************
     File                 : ColumnDock.cpp
     Project              : LabPlot
     --------------------------------------------------------------------
-    Copyright            : (C) 2011-2018 by Alexander Semke (alexander.semke@web.de)
+	Copyright            : (C) 2011-2019 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2013-2017 by Stefan Gerlach (stefan.gerlach@uni.kn)
     Description          : widget for column properties
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "ColumnDock.h"
 
 #include "backend/core/AbstractFilter.h"
 #include "backend/core/datatypes/SimpleCopyThroughFilter.h"
 #include "backend/core/datatypes/Double2StringFilter.h"
 #include "backend/core/datatypes/String2DoubleFilter.h"
 #include "backend/core/datatypes/DateTime2StringFilter.h"
 #include "backend/core/datatypes/String2DateTimeFilter.h"
+#include "backend/datapicker/DatapickerCurve.h"
 #include "backend/datasources/LiveDataSource.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 
 #include <KLocalizedString>
 
 /*!
   \class ColumnDock
   \brief Provides a widget for editing the properties of the spreadsheet columns currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 
 ColumnDock::ColumnDock(QWidget* parent) : BaseDock(parent) {
 	ui.setupUi(this);
 	m_leName = ui.leName;
 	m_leComment = ui.leComment;
 
 	connect(ui.leName, &QLineEdit::textChanged, this, &ColumnDock::nameChanged);
 	connect(ui.leComment, &QLineEdit::textChanged, this, &ColumnDock::commentChanged);
 	connect(ui.cbType, SIGNAL(currentIndexChanged(int)), this, SLOT(typeChanged(int)));
 	connect(ui.cbFormat, SIGNAL(currentIndexChanged(int)), this, SLOT(formatChanged(int)));
 	connect(ui.sbPrecision, SIGNAL(valueChanged(int)), this, SLOT(precisionChanged(int)) );
 	connect(ui.cbPlotDesignation, SIGNAL(currentIndexChanged(int)), this, SLOT(plotDesignationChanged(int)));
 
 	retranslateUi();
 }
 
 void ColumnDock::setColumns(QList<Column*> list) {
 	m_initializing = true;
 	m_columnsList = list;
 	m_column = list.first();
 	m_aspect = list.first();
 
-	//check whether we have non-editable columns (e.g. columns for residuals calculated in XYFitCurve)
+	//check whether we have non-editable columns:
+	//1. columns in a LiveDataSource
+	//2. columns in the spreadsheet of a datapicker curve
+	//3. columns for residuals calculated in XYFitCurve)
 	bool nonEditable = false;
 	for (auto* col : m_columnsList) {
 		auto* s = dynamic_cast<Spreadsheet*>(col->parentAspect());
 		if (s) {
-			if (dynamic_cast<LiveDataSource*>(s)) {
+			if (dynamic_cast<LiveDataSource*>(s) || dynamic_cast<DatapickerCurve*>(s->parentAspect())) {
 				nonEditable = true;
 				break;
 			}
 		} else {
 			nonEditable = true;
 			break;
 		}
 	}
 
 	if (list.size() == 1) {
 		//names and comments of non-editable columns in a file data source can be changed.
 		if (!nonEditable && dynamic_cast<LiveDataSource*>(m_column->parentAspect()) != nullptr) {
 			ui.leName->setEnabled(false);
 			ui.leComment->setEnabled(false);
 		} else {
 			ui.leName->setEnabled(true);
 			ui.leComment->setEnabled(true);
 		}
 
 		ui.leName->setText(m_column->name());
 		ui.leComment->setText(m_column->comment());
 	} else {
 		ui.leName->setEnabled(false);
 		ui.leComment->setEnabled(false);
 
 		ui.leName->setText(QString());
 		ui.leComment->setText(QString());
 	}
 	ui.leName->setStyleSheet("");
 	ui.leName->setToolTip("");
 
 	//show the properties of the first column
 	AbstractColumn::ColumnMode columnMode = m_column->columnMode();
 	this->updateFormatWidgets(columnMode);
 	this->updateTypeWidgets(columnMode);
 	ui.cbPlotDesignation->setCurrentIndex( int(m_column->plotDesignation()) );
 
-	if (!nonEditable) {
-		// slots
-		connect(m_column, &AbstractColumn::aspectDescriptionChanged, this, &ColumnDock::columnDescriptionChanged);
-		connect(m_column, &AbstractColumn::modeChanged, this, &ColumnDock::columnModeChanged);
-		connect(m_column->outputFilter(), &AbstractSimpleFilter::formatChanged, this, &ColumnDock::columnFormatChanged);
-		connect(m_column->outputFilter(), &AbstractSimpleFilter::digitsChanged, this, &ColumnDock::columnPrecisionChanged);
-		connect(m_column, &AbstractColumn::plotDesignationChanged, this, &ColumnDock::columnPlotDesignationChanged);
-	} else {
-		//don't allow to change the column type at least one non-editable column
-		ui.cbType->setEnabled(false);
-	}
+	// slots
+	connect(m_column, &AbstractColumn::aspectDescriptionChanged, this, &ColumnDock::columnDescriptionChanged);
+	connect(m_column, &AbstractColumn::modeChanged, this, &ColumnDock::columnModeChanged);
+	connect(m_column->outputFilter(), &AbstractSimpleFilter::formatChanged, this, &ColumnDock::columnFormatChanged);
+	connect(m_column->outputFilter(), &AbstractSimpleFilter::digitsChanged, this, &ColumnDock::columnPrecisionChanged);
+	connect(m_column, &AbstractColumn::plotDesignationChanged, this, &ColumnDock::columnPlotDesignationChanged);
+
+	//don't allow to change the column type at least one non-editable column
+	ui.cbType->setEnabled(!nonEditable);
 
 	m_initializing = false;
 }
 
 void ColumnDock::updateTypeWidgets(AbstractColumn::ColumnMode mode) {
 	ui.cbType->setCurrentIndex(ui.cbType->findData((int)mode));
 	switch (mode) {
 	case AbstractColumn::Numeric: {
 			auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->numericFormat()));
 			ui.sbPrecision->setValue(filter->numDigits());
 			break;
 		}
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
 			auto* filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
 			DEBUG("	set column format: " << filter->format().toStdString());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->format()));
 			break;
 		}
 	case AbstractColumn::Integer:	// nothing to set
 	case AbstractColumn::Text:
 		break;
 	}
 }
 
 /*!
   depending on the currently selected column type (column mode) updates the widgets for the column format,
   shows/hides the allowed widgets, fills the corresponding combobox with the possible entries.
   Called when the type (column mode) is changed.
 */
 void ColumnDock::updateFormatWidgets(AbstractColumn::ColumnMode mode) {
 	ui.cbFormat->clear();
 
 	switch (mode) {
 	case AbstractColumn::Numeric:
 		ui.cbFormat->addItem(i18n("Decimal"), QVariant('f'));
 		ui.cbFormat->addItem(i18n("Scientific (e)"), QVariant('e'));
 		ui.cbFormat->addItem(i18n("Scientific (E)"), QVariant('E'));
 		ui.cbFormat->addItem(i18n("Automatic (g)"), QVariant('g'));
 		ui.cbFormat->addItem(i18n("Automatic (G)"), QVariant('G'));
 		break;
 	case AbstractColumn::Month:
 		ui.cbFormat->addItem(i18n("Number without Leading Zero"), QVariant("M"));
 		ui.cbFormat->addItem(i18n("Number with Leading Zero"), QVariant("MM"));
 		ui.cbFormat->addItem(i18n("Abbreviated Month Name"), QVariant("MMM"));
 		ui.cbFormat->addItem(i18n("Full Month Name"), QVariant("MMMM"));
 		break;
 	case AbstractColumn::Day:
 		ui.cbFormat->addItem(i18n("Number without Leading Zero"), QVariant("d"));
 		ui.cbFormat->addItem(i18n("Number with Leading Zero"), QVariant("dd"));
 		ui.cbFormat->addItem(i18n("Abbreviated Day Name"), QVariant("ddd"));
 		ui.cbFormat->addItem(i18n("Full Day Name"), QVariant("dddd"));
 		break;
 	case AbstractColumn::DateTime:
 		for (const auto& s : AbstractColumn::dateTimeFormats())
 			ui.cbFormat->addItem(s, QVariant(s));
 		break;
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	}
 
 	if (mode == AbstractColumn::Numeric) {
 		ui.lPrecision->show();
 		ui.sbPrecision->show();
 	} else {
 		ui.lPrecision->hide();
 		ui.sbPrecision->hide();
 	}
 
 	if (mode == AbstractColumn::Text || mode == AbstractColumn::Integer) {
 		ui.lFormat->hide();
 		ui.cbFormat->hide();
 	} else {
 		ui.lFormat->show();
 		ui.cbFormat->show();
 	}
 
 	if (mode == AbstractColumn::DateTime) {
 		ui.cbFormat->setEditable(true);
 		ui.cbFormat->setCurrentItem("yyyy-MM-dd hh:mm:ss.zzz");
 	} else {
 		ui.cbFormat->setEditable(false);
 		ui.cbFormat->setCurrentIndex(0);
 	}
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in ColumnDock **********
 //*************************************************************
 void ColumnDock::retranslateUi() {
 	m_initializing = true;
 
 	ui.cbType->clear();
 	ui.cbType->addItem(i18n("Numeric"), QVariant(int(AbstractColumn::Numeric)));
 	ui.cbType->addItem(i18n("Integer"), QVariant(int(AbstractColumn::Integer)));
 	ui.cbType->addItem(i18n("Text"), QVariant(int(AbstractColumn::Text)));
 	ui.cbType->addItem(i18n("Month Names"), QVariant(int(AbstractColumn::Month)));
 	ui.cbType->addItem(i18n("Day Names"), QVariant(int(AbstractColumn::Day)));
 	ui.cbType->addItem(i18n("Date and Time"), QVariant(int(AbstractColumn::DateTime)));
 
 	ui.cbPlotDesignation->clear();
 	ui.cbPlotDesignation->addItem(i18n("None"));
 	ui.cbPlotDesignation->addItem(i18n("X"));
 	ui.cbPlotDesignation->addItem(i18n("Y"));
 	ui.cbPlotDesignation->addItem(i18n("Z"));
 	ui.cbPlotDesignation->addItem(i18n("X-error"));
 	ui.cbPlotDesignation->addItem(i18n("X-error -"));
 	ui.cbPlotDesignation->addItem(i18n("X-error +"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error -"));
 	ui.cbPlotDesignation->addItem(i18n("Y-error +"));
 
 	m_initializing = false;
 }
 
 /*!
   called when the type (column mode - numeric, text etc.) of the column was changed.
 */
 void ColumnDock::typeChanged(int index) {
 	DEBUG("ColumnDock::typeChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractColumn::ColumnMode columnMode = (AbstractColumn::ColumnMode)ui.cbType->itemData(index).toInt();
 
 	m_initializing = true;
 	this->updateFormatWidgets(columnMode);
 	m_initializing = false;
 
 	switch (columnMode) {
 	case AbstractColumn::Numeric: {
 			int digits = ui.sbPrecision->value();
 			for (auto* col : m_columnsList) {
 				col->beginMacro(i18n("%1: change column type", col->name()));
 				col->setColumnMode(columnMode);
 				auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 
 				//TODO: using
 				//char format = ui.cbFormat->itemData(ui.cbFormat->currentIndex()).toChar().toLatin1();
 				//outside of the for-loop and
 				//filter->setNumericFormat(format);
 				//inseide the loop leads to wrong results when converting from integer to numeric -> 'f' is set instead of 'e'
 				filter->setNumericFormat(ui.cbFormat->itemData(ui.cbFormat->currentIndex()).toChar().toLatin1());
 				filter->setNumDigits(digits);
 				col->endMacro();
 			}
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		for (auto* col : m_columnsList)
 			col->setColumnMode(columnMode);
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 		for (auto* col : m_columnsList) {
 			col->beginMacro(i18n("%1: change column type", col->name()));
 			// the format is saved as item data
 			QString format = ui.cbFormat->itemData(ui.cbFormat->currentIndex()).toString();
 			col->setColumnMode(columnMode);
 			auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			col->endMacro();
 		}
 		break;
 	case AbstractColumn::DateTime:
 		for (auto* col : m_columnsList) {
 			col->beginMacro(i18n("%1: change column type", col->name()));
 			// the format is the current text
 			QString format = ui.cbFormat->currentText();
 			col->setColumnMode(columnMode);
 			auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 			filter->setFormat(format);
 			col->endMacro();
 		}
 		break;
 	}
 	DEBUG("ColumnDock::typeChanged() DONE");
 }
 
 /*!
   called when the format for the current type (column mode) was changed.
 */
 void ColumnDock::formatChanged(int index) {
 	DEBUG("ColumnDock::formatChanged()");
 	if (m_initializing)
 		return;
 
 	AbstractColumn::ColumnMode mode = (AbstractColumn::ColumnMode)ui.cbType->itemData(ui.cbType->currentIndex()).toInt();
 
 	switch (mode) {
 	case AbstractColumn::Numeric: {
 			char format = ui.cbFormat->itemData(index).toChar().toLatin1();
 			for (auto* col : m_columnsList) {
 				auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 				filter->setNumericFormat(format);
 			}
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
 			QString format = ui.cbFormat->itemData(index).toString();
 			for (auto* col : m_columnsList) {
 				auto* filter = static_cast<DateTime2StringFilter*>(col->outputFilter());
 				filter->setFormat(format);
 			}
 			break;
 		}
 	}
 	DEBUG("ColumnDock::formatChanged() DONE");
 }
 
 void ColumnDock::precisionChanged(int digits) {
 	if (m_initializing)
 		return;
 
 	for (auto* col : m_columnsList) {
 		auto* filter = static_cast<Double2StringFilter*>(col->outputFilter());
 		filter->setNumDigits(digits);
 	}
 }
 
 void ColumnDock::plotDesignationChanged(int index) {
 	if (m_initializing)
 		return;
 
 	auto pd = AbstractColumn::PlotDesignation(index);
 	for (auto* col : m_columnsList)
 		col->setPlotDesignation(pd);
 }
 
 //*************************************************************
 //********* SLOTs for changes triggered in Column *************
 //*************************************************************
 void ColumnDock::columnDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_column != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.leComment->text())
 		ui.leComment->setText(aspect->comment());
 	m_initializing = false;
 }
 
 void ColumnDock::columnModeChanged(const AbstractAspect* aspect) {
 	if (m_column != aspect)
 		return;
 
 	m_initializing = true;
 	AbstractColumn::ColumnMode columnMode = m_column->columnMode();
 	this->updateFormatWidgets(columnMode);
 	this->updateTypeWidgets(columnMode);
 	m_initializing = false;
 }
 
 void ColumnDock::columnFormatChanged() {
 	DEBUG("ColumnDock::columnFormatChanged()");
 	m_initializing = true;
 	AbstractColumn::ColumnMode columnMode = m_column->columnMode();
 	switch (columnMode) {
 	case AbstractColumn::Numeric: {
 			auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->numericFormat()));
 			break;
 		}
 	case AbstractColumn::Integer:
 	case AbstractColumn::Text:
 		break;
 	case AbstractColumn::Month:
 	case AbstractColumn::Day:
 	case AbstractColumn::DateTime: {
 			auto* filter = static_cast<DateTime2StringFilter*>(m_column->outputFilter());
 			ui.cbFormat->setCurrentIndex(ui.cbFormat->findData(filter->format()));
 			break;
 		}
 	}
 	m_initializing = false;
 }
 
 void ColumnDock::columnPrecisionChanged() {
 	m_initializing = true;
 	auto* filter = static_cast<Double2StringFilter*>(m_column->outputFilter());
 	ui.sbPrecision->setValue(filter->numDigits());
 	m_initializing = false;
 }
 
 void ColumnDock::columnPlotDesignationChanged(const AbstractColumn* col) {
 	m_initializing = true;
 	ui.cbPlotDesignation->setCurrentIndex( int(col->plotDesignation()) );
 	m_initializing = false;
 }
diff --git a/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp b/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
index b5a687951..9c9d697a5 100644
--- a/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
+++ b/src/kdefrontend/dockwidgets/SpreadsheetDock.cpp
@@ -1,228 +1,248 @@
 /***************************************************************************
     File                 : SpreadsheetDock.cpp
     Project              : LabPlot
     Description          : widget for spreadsheet properties
-    --------------------------------------------------------------------
-    Copyright            : (C) 2010-2015 by Alexander Semke (alexander.semke@web.de)
+	--------------------------------------------------------------------
+	Copyright            : (C) 2010-2019 by Alexander Semke (alexander.semke@web.de)
     Copyright            : (C) 2012-2013 by Stefan Gerlach (stefan.gerlach@uni-konstanz.de)
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *  This program is free software; you can redistribute it and/or modify   *
  *  it under the terms of the GNU General Public License as published by   *
  *  the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                         *
  *  This program is distributed in the hope that it will be useful,        *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  *  GNU General Public License for more details.                           *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the Free Software           *
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
  *   Boston, MA  02110-1301  USA                                           *
  *                                                                         *
  ***************************************************************************/
 
 #include "SpreadsheetDock.h"
 #include "commonfrontend/spreadsheet/SpreadsheetView.h"
+#include "backend/datapicker/DatapickerCurve.h"
 #include "backend/spreadsheet/Spreadsheet.h"
 #include "kdefrontend/TemplateHandler.h"
+
 #include <QDir>
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KConfig>
 
  /*!
   \class SpreadsheetDock
   \brief Provides a widget for editing the properties of the spreadsheets currently selected in the project explorer.
 
   \ingroup kdefrontend
 */
 
-SpreadsheetDock::SpreadsheetDock(QWidget* parent): BaseDock(parent) {
+SpreadsheetDock::SpreadsheetDock(QWidget* parent) : BaseDock(parent) {
 	ui.setupUi(this);
 	m_leName = ui.leName;
 	//leComment = ui.teComment; // is not a lineedit
 
 	connect(ui.leName, &QLineEdit::textChanged, this, &SpreadsheetDock::nameChanged);
 	connect(ui.teComment, &QTextEdit::textChanged, this, &SpreadsheetDock::commentChanged);
 	connect(ui.sbColumnCount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &SpreadsheetDock::columnCountChanged);
 	connect(ui.sbRowCount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &SpreadsheetDock::rowCountChanged);
 	connect(ui.cbShowComments, &QCheckBox::stateChanged, this, &SpreadsheetDock::commentsShownChanged);
 
 	auto* templateHandler = new TemplateHandler(this, TemplateHandler::Spreadsheet);
 	ui.gridLayout->addWidget(templateHandler, 11, 0, 1, 4);
 	templateHandler->show();
 	connect(templateHandler, &TemplateHandler::loadConfigRequested, this, &SpreadsheetDock::loadConfigFromTemplate);
 	connect(templateHandler, &TemplateHandler::saveConfigRequested, this, &SpreadsheetDock::saveConfigAsTemplate);
 	connect(templateHandler, &TemplateHandler::info, this, &SpreadsheetDock::info);
 }
 
 /*!
 	set the current spreadsheet(s)
 */
 void SpreadsheetDock::setSpreadsheets(QList<Spreadsheet*> list) {
 	m_initializing = true;
 	m_spreadsheetList = list;
 	m_spreadsheet = list.first();
 	m_aspect = list.first();
 
+
+	//check whether we have non-editable columns:
+	bool nonEditable = false;
+	for (auto* s : m_spreadsheetList) {
+		if (dynamic_cast<DatapickerCurve*>(s->parentAspect())) {
+			nonEditable = true;
+			break;
+		}
+	}
+
 	if (list.size() == 1) {
 		ui.leName->setEnabled(true);
 		ui.teComment->setEnabled(true);
 
 		ui.leName->setText(m_spreadsheet->name());
 		ui.teComment->setText(m_spreadsheet->comment());
 	} else {
 		//disable the fields "Name" and "Comment" if there are more then one spreadsheet
 		ui.leName->setEnabled(false);
 		ui.teComment->setEnabled(false);
 
 		ui.leName->setText(QString());
 		ui.teComment->setText(QString());
-  	}
+	}
 	ui.leName->setStyleSheet("");
 	ui.leName->setToolTip("");
 
 	//show the properties of the first Spreadsheet in the list
 	this->load();
 
 	// undo functions
-	connect(m_spreadsheet, SIGNAL(aspectDescriptionChanged(const AbstractAspect*)),
-			this, SLOT(spreadsheetDescriptionChanged(const AbstractAspect*)));
-	connect(m_spreadsheet, SIGNAL(rowCountChanged(int)),this, SLOT(spreadsheetRowCountChanged(int)));
-	connect(m_spreadsheet, SIGNAL(columnCountChanged(int)),this, SLOT(spreadsheetColumnCountChanged(int)));
+	connect(m_spreadsheet, &AbstractAspect::aspectDescriptionChanged, this, &SpreadsheetDock::spreadsheetDescriptionChanged);
+	connect(m_spreadsheet, &Spreadsheet::rowCountChanged, this, &SpreadsheetDock::spreadsheetRowCountChanged);
+	connect(m_spreadsheet, &Spreadsheet::columnCountChanged, this, &SpreadsheetDock::spreadsheetColumnCountChanged);
 	//TODO: show comments
 
+	ui.lDimensions->setVisible(!nonEditable);
+	ui.lRowCount->setVisible(!nonEditable);
+	ui.sbRowCount->setVisible(!nonEditable);
+	ui.lColumnCount->setVisible(!nonEditable);
+	ui.sbColumnCount->setVisible(!nonEditable);
+	ui.lFormat->setVisible(!nonEditable);
+	ui.lShowComments->setVisible(!nonEditable);
+	ui.cbShowComments->setVisible(!nonEditable);
+
 	m_initializing = false;
 }
 
 //*************************************************************
 //****** SLOTs for changes triggered in SpreadsheetDock *******
 //*************************************************************
 void SpreadsheetDock::commentChanged() {
 	if (m_initializing)
 		return;
 
 	m_spreadsheet->setComment(ui.teComment->document()->toPlainText());
 }
 
 void SpreadsheetDock::rowCountChanged(int rows) {
 	if (m_initializing)
 		return;
 
 	for (auto* spreadsheet : m_spreadsheetList)
 		spreadsheet->setRowCount(rows);
 }
 
 void SpreadsheetDock::columnCountChanged(int columns) {
 	if (m_initializing)
 		return;
 
 	for (auto* spreadsheet : m_spreadsheetList)
 		spreadsheet->setColumnCount(columns);
 }
 
 /*!
   switches on/off  the comment header in the views of the selected spreadsheets.
 */
 void SpreadsheetDock::commentsShownChanged(int state) {
 	if (m_initializing)
 		return;
 
 	for (auto* spreadsheet : m_spreadsheetList)
 		qobject_cast<SpreadsheetView*>(spreadsheet->view())->showComments(state);
 }
 
 //*************************************************************
 //******** SLOTs for changes triggered in Spreadsheet *********
 //*************************************************************
 void SpreadsheetDock::spreadsheetDescriptionChanged(const AbstractAspect* aspect) {
 	if (m_spreadsheet != aspect)
 		return;
 
 	m_initializing = true;
 	if (aspect->name() != ui.leName->text())
 		ui.leName->setText(aspect->name());
 	else if (aspect->comment() != ui.teComment->toPlainText())
 		ui.teComment->document()->setPlainText(aspect->comment());
 
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetRowCountChanged(int count) {
 	m_initializing = true;
   	ui.sbRowCount->setValue(count);
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetColumnCountChanged(int count) {
 	m_initializing = true;
   	ui.sbColumnCount->setValue(count);
 	m_initializing = false;
 }
 
 void SpreadsheetDock::spreadsheetShowCommentsChanged(int checked) {
 	m_initializing = true;
 	ui.cbShowComments->setChecked(checked);
 	m_initializing = false;
 }
 
 //*************************************************************
 //******************** SETTINGS *******************************
 //*************************************************************
 void SpreadsheetDock::load() {
 	ui.sbColumnCount->setValue(m_spreadsheet->columnCount());
 	ui.sbRowCount->setValue(m_spreadsheet->rowCount());
 
 	auto* view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
 	ui.cbShowComments->setChecked(view->areCommentsShown());
 }
 
 void SpreadsheetDock::loadConfigFromTemplate(KConfig& config) {
 	//extract the name of the template from the file name
 	QString name;
 	const int index = config.name().lastIndexOf(QDir::separator());
 	if (index != -1)
 		name = config.name().right(config.name().size() - index - 1);
 	else
 		name = config.name();
 
 	const int size = m_spreadsheetList.size();
 	if (size > 1)
 		m_spreadsheet->beginMacro(i18n("%1 spreadsheets: template \"%2\" loaded", size, name));
 	else
 		m_spreadsheet->beginMacro(i18n("%1: template \"%2\" loaded", m_spreadsheet->name(), name));
 
 	this->loadConfig(config);
 
 	m_spreadsheet->endMacro();
 }
 
 /*!
 	loads saved spreadsheet properties from \c config.
  */
 void SpreadsheetDock::loadConfig(KConfig& config) {
 	KConfigGroup group = config.group( "Spreadsheet" );
 
 	ui.sbColumnCount->setValue(group.readEntry("ColumnCount", m_spreadsheet->columnCount()));
 	ui.sbRowCount->setValue(group.readEntry("RowCount", m_spreadsheet->rowCount()));
 
 	auto* view = qobject_cast<SpreadsheetView*>(m_spreadsheet->view());
 	ui.cbShowComments->setChecked(group.readEntry("ShowComments", view->areCommentsShown()));
 }
 
 /*!
 	saves spreadsheet properties to \c config.
  */
 void SpreadsheetDock::saveConfigAsTemplate(KConfig& config) {
 	KConfigGroup group = config.group( "Spreadsheet" );
 	group.writeEntry("ColumnCount", ui.sbColumnCount->value());
 	group.writeEntry("RowCount", ui.sbRowCount->value());
 	group.writeEntry("ShowComments",ui.cbShowComments->isChecked());
 	config.sync();
 }
diff --git a/src/kdefrontend/ui/dockwidgets/spreadsheetdock.ui b/src/kdefrontend/ui/dockwidgets/spreadsheetdock.ui
index 8dbc9bb39..cdac4abd1 100644
--- a/src/kdefrontend/ui/dockwidgets/spreadsheetdock.ui
+++ b/src/kdefrontend/ui/dockwidgets/spreadsheetdock.ui
@@ -1,196 +1,196 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>SpreadsheetDock</class>
  <widget class="QWidget" name="SpreadsheetDock">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>425</width>
     <height>324</height>
    </rect>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QLabel" name="lName">
      <property name="text">
       <string>Name:</string>
      </property>
     </widget>
    </item>
    <item row="0" column="2">
     <spacer name="horizontalSpacer_4">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>10</width>
        <height>23</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="0" column="3">
     <widget class="QLineEdit" name="leName"/>
    </item>
    <item row="1" column="0">
     <widget class="QLabel" name="lComment">
      <property name="text">
       <string>Comment:</string>
      </property>
     </widget>
    </item>
    <item row="1" column="3">
     <widget class="ResizableTextEdit" name="teComment">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="maximumSize">
       <size>
        <width>16777215</width>
        <height>16777215</height>
       </size>
      </property>
     </widget>
    </item>
    <item row="2" column="0">
     <spacer name="verticalSpacer_3">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>58</width>
        <height>13</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="3" column="0">
     <widget class="QLabel" name="lDimensions">
      <property name="font">
       <font>
        <weight>75</weight>
        <bold>true</bold>
       </font>
      </property>
      <property name="text">
       <string>Dimensions</string>
      </property>
     </widget>
    </item>
    <item row="4" column="0">
     <widget class="QLabel" name="lRowCount">
      <property name="text">
       <string>Rows:</string>
      </property>
     </widget>
    </item>
    <item row="4" column="3">
     <widget class="QSpinBox" name="sbRowCount">
      <property name="minimum">
       <number>0</number>
      </property>
      <property name="maximum">
       <number>16777215</number>
      </property>
     </widget>
    </item>
    <item row="5" column="0">
     <widget class="QLabel" name="lColumnCount">
      <property name="text">
       <string>Columns:</string>
      </property>
     </widget>
    </item>
    <item row="5" column="3">
     <widget class="QSpinBox" name="sbColumnCount">
      <property name="minimum">
       <number>0</number>
      </property>
      <property name="maximum">
       <number>16777215</number>
      </property>
     </widget>
    </item>
    <item row="6" column="0">
     <spacer name="verticalSpacer_4">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>58</width>
        <height>13</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="7" column="0">
-    <widget class="QLabel" name="lFormat_2">
+    <widget class="QLabel" name="lFormat">
      <property name="font">
       <font>
        <weight>75</weight>
        <bold>true</bold>
       </font>
      </property>
      <property name="text">
       <string>Format</string>
      </property>
     </widget>
    </item>
    <item row="8" column="0" colspan="2">
     <widget class="QLabel" name="lShowComments">
      <property name="text">
       <string>Column comments:</string>
      </property>
     </widget>
    </item>
    <item row="8" column="3">
     <widget class="QCheckBox" name="cbShowComments">
      <property name="text">
       <string/>
      </property>
      <property name="checked">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item row="9" column="1">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>13</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>ResizableTextEdit</class>
    <extends>QTextEdit</extends>
    <header>src/kdefrontend/widgets/ResizableTextEdit.h</header>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>