diff --git a/src/backend/datasources/filters/ROOTFilter.h b/src/backend/datasources/filters/ROOTFilter.h
--- a/src/backend/datasources/filters/ROOTFilter.h
+++ b/src/backend/datasources/filters/ROOTFilter.h
@@ -30,11 +30,14 @@
 
 #include "backend/datasources/filters/AbstractFileFilter.h"
 
+#include <QList>
+#include <QStringList>
+#include <QVector>
+
 class ROOTFilterPrivate;
 class QStringList;
 class QIODevice;
 
-
 /// Manages the importing of histograms from ROOT files
 class ROOTFilter : public AbstractFileFilter {
 	Q_OBJECT
@@ -61,44 +64,56 @@
 
 	/// List names of histograms contained in ROOT file
 	QStringList listHistograms(const QString& fileName);
+	/// List names of trees contained in ROOT file
+	QStringList listTrees(const QString& fileName);
+	/// List names of leaves contained in ROOT tree
+	QVector<QStringList> listLeaves(const QString& fileName, const QString& treeName);
 
 	/// Set the current histograms, which is one out of listHistograms
-	void setCurrentHistogram(const QString&);
+	void setCurrentObject(const QString&);
 	/// Get the name of the currently set histogram
-	const QString currentHistogram() const;
+	const QString currentObject() const;
 
 	/// Get preview data of the currently set histogram
-	QVector<QStringList> previewCurrentHistogram(const QString& fileName,
+	QVector<QStringList> previewCurrentObject(const QString& fileName,
 	                                             int first, int last);
 
 	/// Get the number of bins in the current histogram
-	int binsInCurrentHistogram(const QString& fileName);
+	int rowsInCurrentObject(const QString& fileName);
 
 	/**
-	 * @brief Set the first bin of the histogram to be read
+	 * @brief Set the first bin of the object to be read
 	 *
-	 * The default of -1 skips the underflow bin with index 0
+	 * -1 skips the underflow bin of histograms
 	 */
-	void setStartBin(const int bin);
-	/// Get the index of the first bin to be read
-	int startBin() const;
+	void setStartRow(const int bin);
+	/// Get the index of the first row to be read
+	int startRow() const;
 	/**
 	 * @brief Set the last bin of the histogram to be read
 	 *
-	 * The default of -1 skips the overflow bin
+	 * -1 skips the overflow row of histograms
 	 */
-	void setEndBin(const int bin);
+	void setEndRow(const int bin);
 	/// Get the index of the last bin to be read
-	int endBin() const;
+	int endRow() const;
 
 	/**
 	 * @brief Set the first column of the histogram to be read
 	 *
 	 * The following columns are available: Bin Center, Content, Error
 	 */
-	void setColumns(const int columns);
-	/// Get the index of the first column to be read
-	int columns() const;
+	void setColumns(const QVector<QStringList>& columns);
+	/**
+     * @brief Get the colums to be read
+     *
+     * For histograms, the identifiers for location, content and error are given
+     * as the first part, the corresponding translation as the second part.
+     * For trees, the branch name and the leaf name are returned.
+     *
+     * @return A pair of strings with different content depending on the object type
+     */
+	QVector<QStringList> columns() const;
 
 	/// Save bin limitation settings
 	void save(QXmlStreamWriter*) const override;
diff --git a/src/backend/datasources/filters/ROOTFilter.cpp b/src/backend/datasources/filters/ROOTFilter.cpp
--- a/src/backend/datasources/filters/ROOTFilter.cpp
+++ b/src/backend/datasources/filters/ROOTFilter.cpp
@@ -33,6 +33,8 @@
 
 #include <KLocalizedString>
 
+#include <QDebug>
+
 #ifdef HAVE_ZIP
 
 #include <lz4.h>
@@ -68,81 +70,82 @@
 	Q_UNUSED(filterName);
 }
 
-void ROOTFilter::setCurrentHistogram(const QString& histogram) {
-	d->currentHistogram = histogram;
+void ROOTFilter::setCurrentObject(const QString& object) {
+	d->currentObject = object;
 }
 
-const QString ROOTFilter::currentHistogram() const {
-	return d->currentHistogram;
+const QString ROOTFilter::currentObject() const {
+	return d->currentObject;
 }
 
 QStringList ROOTFilter::listHistograms(const QString& fileName) {
 	return d->listHistograms(fileName);
 }
 
-QVector<QStringList> ROOTFilter::previewCurrentHistogram(const QString& fileName,
-                                                         int first, int last) {
-	return d->previewCurrentHistogram(fileName, first, last);
+QStringList ROOTFilter::listTrees(const QString& fileName) {
+	return d->listTrees(fileName);
+}
+
+QVector<QStringList> ROOTFilter::listLeaves(const QString& fileName, const QString& treeName) {
+	return d->listLeaves(fileName, treeName);
 }
 
-int ROOTFilter::binsInCurrentHistogram(const QString& fileName) {
-	return d->binsInCurrentHistogram(fileName);
+QVector<QStringList> ROOTFilter::previewCurrentObject(const QString& fileName,
+                                                      int first, int last) {
+	return d->previewCurrentObject(fileName, first, last);
 }
 
-void ROOTFilter::setStartBin(const int s) {
-	d->startBin = s;
+int ROOTFilter::rowsInCurrentObject(const QString& fileName) {
+	return d->rowsInCurrentObject(fileName);
 }
 
-int ROOTFilter::startBin() const {
-	return d->startBin;
+void ROOTFilter::setStartRow(const int s) {
+	d->startRow = s;
 }
 
-void ROOTFilter::setEndBin(const int e) {
-	d->endBin = e;
+int ROOTFilter::startRow() const {
+	return d->startRow;
 }
 
-int ROOTFilter::endBin() const {
-	return d->endBin;
+void ROOTFilter::setEndRow(const int e) {
+	d->endRow = e;
 }
 
-void ROOTFilter::setColumns(const int columns) {
+int ROOTFilter::endRow() const {
+	return d->endRow;
+}
+
+void ROOTFilter::setColumns(const QVector<QStringList>& columns) {
 	d->columns = columns;
 }
 
-int ROOTFilter::columns() const {
+QVector<QStringList> ROOTFilter::columns() const {
 	return d->columns;
 }
 
 void ROOTFilter::save(QXmlStreamWriter* writer) const {
 	writer->writeStartElement("rootFilter");
-	writer->writeAttribute("startBin", QString::number(d->startBin) );
-	writer->writeAttribute("endBin", QString::number(d->endBin) );
-	writer->writeAttribute("columns", QString::number(d->columns) );
+	writer->writeAttribute("startRow", QString::number(d->startRow) );
+	writer->writeAttribute("endRow", QString::number(d->endRow) );
 	writer->writeEndElement();
 }
 
 bool ROOTFilter::load(XmlStreamReader* reader) {
 	QString attributeWarning = i18n("Attribute '%1' missing or empty, default value is used");
 	QXmlStreamAttributes attribs = reader->attributes();
 
 	// read attributes
-	QString str = attribs.value("startBin").toString();
+	QString str = attribs.value("startRow").toString();
 	if (str.isEmpty())
-		reader->raiseWarning(attributeWarning.arg("'startBin'"));
+		reader->raiseWarning(attributeWarning.arg("'startRow'"));
 	else
-		d->startBin = str.toInt();
+		d->startRow = str.toInt();
 
-	str = attribs.value("endBin").toString();
+	str = attribs.value("endRow").toString();
 	if (str.isEmpty())
-		reader->raiseWarning(attributeWarning.arg("'endBin'"));
+		reader->raiseWarning(attributeWarning.arg("'endRow'"));
 	else
-		d->endBin = str.toInt();
-
-	str = attribs.value("columns").toString();
-	if (str.isEmpty())
-		reader->raiseWarning(attributeWarning.arg("'columns'"));
-	else
-		d->columns = str.toInt();
+		d->endRow = str.toInt();
 
 	return true;
 }
@@ -152,177 +155,295 @@
 ROOTFilterPrivate::ROOTFilterPrivate() = default;
 
 void ROOTFilterPrivate::readDataFromFile(const QString& fileName, AbstractDataSource* dataSource,
-		AbstractFileFilter::ImportMode importMode) {
+                                         AbstractFileFilter::ImportMode importMode) {
 	DEBUG("ROOTFilterPrivate::readDataFromFile()");
 
 	setFile(fileName);
 
-	auto bins = readHistogram();
-	const int nbins = (int)bins.size();
-
-	// skip underflow and overflow bins by default
-	int first = qMax(startBin, 0);
-	int last = qMin(endBin, nbins - 1);
-
-	QStringList colNames = createHeaders();
-
-	QVector<void*> dataContainer;
-	const int columnOffset = dataSource->prepareImport(dataContainer, importMode, last - first + 1, colNames.size(),
-			colNames, QVector<AbstractColumn::ColumnMode>(colNames.size(), AbstractColumn::Numeric));
-
-	// read data
-	DEBUG("reading " << first - last + 1 << " lines");
+	QStringList typeobject = currentObject.split(':');
+	if (typeobject.size() < 2)
+		return;
+	if (typeobject.first() == QStringLiteral("Hist")) {
+		typeobject.removeFirst();
+		auto bins = readHistogram(typeobject.join(':'));
+		const int nbins = static_cast<int>(bins.size());
+
+		// skip underflow and overflow bins by default
+		int first = qMax(qAbs(startRow), 0);
+		int last = endRow < 0 ? nbins - 1 : qMax(first - 1, qMin(endRow, nbins - 1));
+
+		QStringList headers;
+		for (const auto& l : columns) {
+			headers << l.last();
+		}
 
-	int c = 0;
-	Spreadsheet* spreadsheet = dynamic_cast<Spreadsheet*>(dataSource);
-	if (columns & ROOTFilter::Center) {
-		if (spreadsheet)
-			spreadsheet->column(columnOffset)->setPlotDesignation(Column::X);
+		QVector<void*> dataContainer;
+		const int columnOffset = dataSource->prepareImport(dataContainer, importMode, last - first + 1, columns.size(),
+		                                                   headers, QVector<AbstractColumn::ColumnMode>(columns.size(),
+		                                                   AbstractColumn::Numeric));
+
+		// read data
+		DEBUG("	reading " << first - last + 1 << " lines");
+
+		int c = 0;
+		Spreadsheet* spreadsheet = dynamic_cast<Spreadsheet*>(dataSource);
+
+		for (const auto& l : columns) {
+			QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c]);
+			if (l.first() == QStringLiteral("center")) {
+				if (spreadsheet)
+					spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::X);
+				for (int i = first; i <= last; ++i)
+					container[i - first] = (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
+					                                                : i == 0 ? bins.front().lowedge   // -infinity
+					                                                         : -bins.front().lowedge; // +infinity
+			} else if (l.first() == QStringLiteral("low")) {
+				if (spreadsheet)
+					spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::X);
+				for (int i = first; i <= last; ++i)
+					container[i - first] = bins[i].lowedge;
+			} else if (l.first() == QStringLiteral("content")) {
+				if (spreadsheet)
+					spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::Y);
+				for (int i = first; i <= last; ++i)
+					container[i - first] = bins[i].content;
+			} else if (l.first() == QStringLiteral("error")) {
+				if (spreadsheet)
+					spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::YError);
+				for (int i = first; i <= last; ++i)
+					container[i - first] = std::sqrt(bins[i].sumw2);
+			}
+			++c;
+		}
 
-		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c]);
-		for (int i = first; i <= last; ++i)
-			container[i - first] = (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
-			                                       : i == 0 ? bins.front().lowedge   // -infinity
-			                                                : -bins.front().lowedge; // +infinity
-		c++;
-	}
-	if (columns & ROOTFilter::Low) {
-		if (spreadsheet)
-			spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::X);
-
-		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c]);
-		for (int i = first; i <= last; ++i)
-			container[i - first] = bins[i].lowedge;
-		c++;
-	}
-	if (columns & ROOTFilter::Content) {
-		if (spreadsheet)
-			spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::Y);
-
-		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c]);
-		for (int i = first; i <= last; ++i)
-			container[i - first] = bins[i].content;
-		c++;
-	}
-	if (columns & ROOTFilter::Error) {
-		if (spreadsheet)
-			spreadsheet->column(columnOffset + c)->setPlotDesignation(Column::XError);
+		dataSource->finalizeImport(columnOffset, 0, columns.size() - 1, -1, QString(), importMode);
+	} else if (typeobject.first() == QStringLiteral("Tree")) {
+		typeobject.removeFirst();
+		const QString treeName = typeobject.join(':');
+		const int nentries = static_cast<int>(currentROOTData->treeEntries(treeName.toStdString()));
+
+		int first = qMax(qAbs(startRow), 0);
+		int last = qMax(first - 1, qMin(endRow, nentries - 1));
+
+		QStringList headers;
+		for (const auto& l : columns) {
+			QString lastelement = l.back(), leaf = l.front();
+			bool isArray = false;
+			if (lastelement.front() == '[' && lastelement.back() == ']') {
+				lastelement.mid(1, lastelement.length() - 2).toUInt(&isArray);
+			}
+			if (!isArray || l.count() == 2)
+				headers << l.join(isArray ? QString() : QString(':'));
+			else
+				headers << l.first() + QChar(':') + l.at(1) + l.back();
+		}
 
-		QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c]);
-		for (int i = first; i <= last; ++i)
-			container[i - first] = std::sqrt(bins[i].sumw2);
-	}
+		QVector<void*> dataContainer;
+		const int columnOffset = dataSource->prepareImport(dataContainer, importMode, last - first + 1, columns.size(),
+		                                                   headers, QVector<AbstractColumn::ColumnMode>(columns.size(),
+		                                                   AbstractColumn::Numeric));
+
+		int c = 0;
+		for (const auto& l : columns) {
+			size_t element = 0;
+			QString lastelement = l.back(), leaf = l.front();
+			bool isArray = false;
+			if (lastelement.front() == '[' && lastelement.back() == ']') {
+				element = lastelement.mid(1, lastelement.length() - 2).toUInt(&isArray);
+				if (!isArray)
+					element = 0;
+				if (l.count() > 2)
+					leaf = l.at(1);
+			} else if (l.count() > 1)
+				leaf = l.at(1);
+
+			QVector<double>& container = *static_cast<QVector<double>*>(dataContainer[c++]);
+			auto data = readTree(treeName, l.first(), leaf, element, last);
+			for (int i = first; i <= last; ++i)
+				container[i - first] = data[i];
+		}
 
-	dataSource->finalizeImport(columnOffset, 0, colNames.size() - 1, -1, QString(), importMode);
+		dataSource->finalizeImport(columnOffset, 0, columns.size() - 1, -1, QString(), importMode);
+    }
 }
 
 void ROOTFilterPrivate::write(const QString& fileName, AbstractDataSource* dataSource) {
 	Q_UNUSED(fileName);
 	Q_UNUSED(dataSource);
-	//TODO: writing ROOT not implemented yet
 }
 
 QStringList ROOTFilterPrivate::listHistograms(const QString& fileName) {
 	setFile(fileName);
 
 	QStringList histList;
-	for (const auto& hist : currentROOTHist->listHistograms()) {
+	for (const auto& hist : currentROOTData->listHistograms()) {
 		histList << QString::fromStdString(hist);
 	}
 
 	return histList;
 }
 
-QVector<QStringList> ROOTFilterPrivate::previewCurrentHistogram(const QString& fileName, int first, int last) {
-	DEBUG("previewCurrentHistogram()");
-
+QStringList ROOTFilterPrivate::listTrees(const QString& fileName) {
 	setFile(fileName);
 
-	auto bins = readHistogram();
-	const int nbins = (int)bins.size();
-
-	last = qMin(nbins - 1, last);
+	QStringList treeList;
+	for (const auto& tree : currentROOTData->listTrees()) {
+		treeList << QString::fromStdString(tree);
+	}
 
-	QVector<QStringList> preview(qMax(last - first + 2, 1));
-	preview.last() = createHeaders();
+	return treeList;
+}
 
-	// read data
-	DEBUG("reading " << preview.size() << " lines");
+QVector<QStringList> ROOTFilterPrivate::listLeaves(const QString& fileName, const QString& treeName) {
+	setFile(fileName);
 
-	if (columns & ROOTFilter::Center) {
-		for (int i = first; i <= last; ++i)
-			preview[i - first] << QString::number(
-			    (i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
-			                    : i == 0 ? bins.front().lowedge    // -infinity
-			                             : -bins.front().lowedge); // +infinity
-	}
-	if (columns & ROOTFilter::Low) {
-		for (int i = first; i <= last; ++i)
-			preview[i - first] << QString::number(bins[i].lowedge);
-	}
-	if (columns & ROOTFilter::Content) {
-		for (int i = first; i <= last; ++i)
-			preview[i - first] << QString::number(bins[i].content);
-	}
-	if (columns & ROOTFilter::Error) {
-		for (int i = first; i <= last; ++i)
-			preview[i - first] << QString::number(std::sqrt(bins[i].sumw2));
+	QVector<QStringList> leafList;
+	for (const auto& leaf : currentROOTData->listLeaves(treeName.toStdString())) {
+		leafList << QStringList(QString::fromStdString(leaf.branch));
+		if (leaf.branch != leaf.leaf)
+			leafList.last() << QString::fromStdString(leaf.leaf);
+		if (leaf.elements > 1)
+			leafList.last() << QString("[%1]").arg(leaf.elements);
 	}
 
-	return preview;
+	return leafList;
 }
 
-int ROOTFilterPrivate::binsInCurrentHistogram(const QString& fileName) {
+QVector<QStringList> ROOTFilterPrivate::previewCurrentObject(const QString& fileName, int first, int last) {
+	DEBUG("ROOTFilterPrivate::previewCurrentObject()");
+
 	setFile(fileName);
 
-	QStringList nameindex = currentHistogram.split(';');
-	bool ok = nameindex.size() > 1;
-	int cycle = ok ? nameindex.last().toInt(&ok) : 1;
-	if (ok) {
-		nameindex.removeLast();
-	} else {
-		cycle = 1;
-	}
+	QStringList typeobject = currentObject.split(':');
+	if (typeobject.size() < 2)
+		return QVector<QStringList>(1, QStringList());
+
+	if (typeobject.first() == QStringLiteral("Hist")) {
+		typeobject.removeFirst();
+		auto bins = readHistogram(typeobject.join(':'));
+		const int nbins = static_cast<int>(bins.size());
+
+		last = qMin(nbins - 1, last);
+
+		QVector<QStringList> preview(qMax(last - first + 2, 1));
+		DEBUG("	reading " << preview.size() - 1 << " lines");
+
+		// set headers
+		for (const auto& l : columns) {
+			preview.last() << l.last();
+		}
+
+		// read data
+		for (const auto& l : columns) {
+			if (l.first() == QStringLiteral("center")) {
+				for (int i = first; i <= last; ++i)
+					preview[i - first] << QString::number(
+						(i > 0 && i < nbins - 1) ? 0.5 * (bins[i].lowedge + bins[i + 1].lowedge)
+						                         : i == 0 ? bins.front().lowedge    // -infinity
+						                                  : -bins.front().lowedge); // +infinity
+			} else if (l.first() == QStringLiteral("low")) {
+				for (int i = first; i <= last; ++i)
+					preview[i - first] << QString::number(bins[i].lowedge);
+			} else if (l.first() == QStringLiteral("content")) {
+				for (int i = first; i <= last; ++i)
+					preview[i - first] << QString::number(bins[i].content);
+			} else if (l.first() == QStringLiteral("error")) {
+				for (int i = first; i <= last; ++i)
+					preview[i - first] << QString::number(std::sqrt(bins[i].sumw2));
+			}
+		}
+
+		return preview;
+	} else if (typeobject.first() == QStringLiteral("Tree")) {
+		typeobject.removeFirst();
+		const QString treeName = typeobject.join(':');
+		last = qMin(last, currentROOTData->treeEntries(treeName.toStdString()) - 1);
+
+		QVector<QStringList> preview(qMax(last - first + 2, 1));
+		DEBUG("	reading " << preview.size() - 1 << " lines");
+
+		// read data leaf by leaf and set headers
+		for (const auto& l : columns) {
+			size_t element = 0;
+			QString lastelement = l.back(), leaf = l.front();
+			bool isArray = false;
+			if (lastelement.front() == '[' && lastelement.back() == ']') {
+				element = lastelement.mid(1, lastelement.length() - 2).toUInt(&isArray);
+				if (!isArray)
+					element = 0;
+				if (l.count() > 2)
+					leaf = l.at(1);
+			} else if (l.count() > 1)
+				leaf = l.at(1);
+
+			auto data = readTree(treeName, l.first(), leaf, element, last);
+			for (int i = first; i <= last; ++i)
+				preview[i - first] << QString::number(data[i]);
+			if (!isArray || l.count() == 2)
+				preview.last() << l.join(isArray ? QString() : QString(':'));
+			else
+				preview.last() << l.first() + QChar(':') + l.at(1) + l.back();
+		}
 
-	return currentROOTHist->histogramBins(nameindex.join(';').toStdString(), cycle);
+		return preview;
+	} else
+		return QVector<QStringList>(1, QStringList());
 }
 
-QStringList ROOTFilterPrivate::createHeaders() {
-	QStringList colNames;
-	if (columns & ROOTFilter::Center)
-		colNames << i18n("Bin Center");
-	if (columns & ROOTFilter::Low)
-		colNames << i18n("Low Edge");
-	if (columns & ROOTFilter::Content)
-		colNames << i18n("Content");
-	if (columns & ROOTFilter::Error)
-		colNames << i18n("Error");
-	return colNames;
+int ROOTFilterPrivate::rowsInCurrentObject(const QString& fileName) {
+	setFile(fileName);
+
+	QStringList typeobject = currentObject.split(':');
+	if (typeobject.size() < 2)
+		return 0;
+	if (typeobject.first() == QStringLiteral("Hist")) {
+		typeobject.removeFirst();
+		QStringList nameindex = typeobject.join(':').split(';');;
+		bool ok = nameindex.size() > 1;
+		int cycle = ok ? nameindex.last().toInt(&ok) : 1;
+		if (ok) {
+			nameindex.removeLast();
+		} else {
+			cycle = 1;
+		}
+
+		return currentROOTData->histogramBins(nameindex.join(';').toStdString(), cycle);
+	} else if (typeobject.first() == QStringLiteral("Tree")) {
+		typeobject.removeFirst();
+		return currentROOTData->treeEntries(typeobject.join(':').toStdString());
+	} else
+		return 0;
 }
 
 void ROOTFilterPrivate::setFile(const QString& fileName) {
-	if (!currentROOTHist || fileName != currentFile) {
+	if (!currentROOTData || fileName != currentFile) {
 		currentFile = fileName;
-		currentROOTHist.reset(new ROOTHist(fileName.toStdString()));
+		currentROOTData.reset(new ROOTData(fileName.toStdString()));
 	}
 }
 
-std::vector<ROOTHist::BinPars> ROOTFilterPrivate::readHistogram() {
-	QStringList nameindex = currentHistogram.split(';');
+std::vector<ROOTData::BinPars> ROOTFilterPrivate::readHistogram(const QString& histName) {
+	QStringList nameindex = histName.split(';');
 	bool ok = nameindex.size() > 1;
 	int cycle = ok ? nameindex.last().toInt(&ok) : 1;
 	if (ok) {
 		nameindex.removeLast();
 	} else {
 		cycle = 1;
 	}
 
-	return currentROOTHist->readHistogram(nameindex.join(';').toStdString(), cycle);
+	return currentROOTData->readHistogram(nameindex.join(';').toStdString(), cycle);
+}
+
+std::vector<double> ROOTFilterPrivate::readTree(const QString& treeName, const QString& branchName, const QString& leafName, int element, int last)
+{
+	return currentROOTData->listEntries<double>(treeName.toStdString(), branchName.toStdString(), leafName.toStdString(), element, last + 1);
 }
 
-/******************** ROOTHist implementation ************************/
 
-namespace ROOTHistHelpers {
+/******************** ROOTData implementation ************************/
+
+namespace ROOTDataHelpers {
 
 /// Read value from stream
 template<class T>
@@ -352,11 +473,18 @@
 	return r.val;
 }
 
+/// Read value from buffer and cast to U
+template<class T, class U>
+U readcast(char*& s) {
+	return static_cast<U>(read<T>(s));
+}
+
 /// Get version of ROOT object, obtain number of bytes in object
 short Version(char*& buffer, size_t& count) {
+	// root/io/io/src/TBufferFile.cxx -> ReadVersion
 	count = read<unsigned int>(buffer);
 	short version = (count & 0x40000000) ? read<short>(buffer) : read<short>(buffer -= 4);
-	count &= (count & 0x40000000) ? (~0x40000000) : 0;
+	count = (count & 0x40000000) ? (count & ~0x40000000) - 2 : 2;
 	return version;
 }
 
@@ -369,10 +497,9 @@
 /// Skip ROOT object
 void Skip(char*& buffer, const size_t& n) {
 	for (size_t i = 0; i < n; ++i) {
-		char* nbuf = buffer + 4;
 		size_t count;
 		Version(buffer, count);
-		buffer = nbuf + count;
+		buffer += count;
 	}
 }
 
@@ -384,6 +511,7 @@
 
 /// Get TString
 std::string String(char*& buffer) {
+	// root/io/io/src/TBufferFile.cxx -> ReadTString
 	size_t s = *(buffer++);
 	if (s == 0)
 		return std::string();
@@ -395,163 +523,277 @@
 	}
 }
 
+/// Get the header of an object in TObjArray
+std::string readObject(char*& buf, char* const buf0, std::map<size_t, std::string>& tags)
+{
+	// root/io/io/src/TBufferFile.cxx -> ReadObjectAny
+	std::string clname;
+	unsigned int tag = read<unsigned int>(buf);
+	if (tag & 0x40000000) {
+		tag = read<unsigned int>(buf);
+		if (tag == 0xFFFFFFFF) {
+			tags[buf - buf0 - 2] = clname = buf;
+			buf += clname.size() + 1;
+		} else {
+			clname = tags[tag & ~0x80000000];
+		}
+	}
+
+	return clname;
+}
+
 }
 
-using namespace ROOTHistHelpers;
+using namespace ROOTDataHelpers;
 
-ROOTHist::ROOTHist(const std::string& filename) : filename(filename) {
+ROOTData::ROOTData(const std::string& filename) : filename(filename) {
 	// The file structure is described in root/io/io/src/TFile.cxx
 	std::ifstream is(filename, std::ifstream::binary);
 	std::string root(4, 0);
 	is.read(const_cast<char*>(root.data()), 4);
 	if (root != "root")
 		return;
 
-	is.seekg(8); // skip version
-	int pos = read<int>(is);
-	is.seekg(16);
-	int lastpos = read<int>(is);
+	int fileVersion = read<int>(is);
+	long int pos = read<int>(is);
+	long int endpos = fileVersion < 1000000 ? read<int>(is) : read<long int>(is);
 
 	is.seekg(33);
-	compression = read<int>(is);
+	int compression = read<int>(is);
 	compression = compression > 0 ? compression : 0;
 
-	while (is.good() && pos < lastpos) {
+	while (is.good() && pos < endpos) {
 		is.seekg(pos);
-		size_t lcdata = read<unsigned int>(is);
-		is.seekg(2, is.cur); // short version = read<short>(is);
+		int lcdata = read<int>(is);
+		if (lcdata == 0) {
+			break;
+		}
+		if (lcdata < 0) {
+			pos -= lcdata;
+			continue;
+		}
+		short version = read<short>(is);
 		size_t ldata = read<unsigned int>(is);
-		is.seekg(4, is.cur);
+		is.seekg(4, is.cur); // skip the date
 		size_t lkey = read<unsigned short int>(is);
 		short cycle = read<short>(is);
-		is.seekg(8, is.cur);
+		is.seekg(version > 1000 ? 16 : 8, is.cur); // skip seek positions
 		std::string cname(read<unsigned char>(is), 0);
 		is.read(&cname[0], cname.size());
+		std::string name(read<unsigned char>(is), 0);
+		is.read(&name[0], name.size());
+		std::string title(read<unsigned char>(is), 0);
+		is.read(&title[0], title.size());
+
+		ContentType type = Invalid;
 		if (cname.size() == 4 && cname.substr(0, 3) == "TH1") {
-			KeyBuffer::ContentType type;
-			switch (cname[3]) {
-				case 'D':
-					type = KeyBuffer::ContentType::Double;
-					break;
-				case 'F':
-					type = KeyBuffer::ContentType::Float;
+			type = histType(cname[3]);
+		} else if (cname == "TTree")
+			type = Tree;
+		else if (cname.substr(0, 7) == "TNtuple")
+			type = NTuple;
+		else if (cname == "TBasket")
+			type = Basket;
+		else if (cname == "TList" && name == "StreamerInfo")
+			type = Streamer;
+
+		if (type) {
+			if (type == Basket)
+				is.seekg(19, std::ifstream::cur); // TODO read info instead?
+			KeyBuffer buffer;
+			buffer.type = Invalid;
+			// see root/io/io/src/TKey.cxx for reference
+			int complib = 0;
+			if (compression) {
+				// Default: compression level
+				// ZLIB: 100 + compression level
+				// LZ4:  400 + compression level
+				// do not rely on this, but read the header
+				std::string lib(2, 0);
+				is.read(&lib[0], 2);
+				complib = lib == "ZL" ? 1 :
+				          lib == "XZ" ? 2 :
+				          lib == "CS" ? 3 :
+				          lib == "L4" ? 4 : 0;
+			}
+			if (complib > 0) {
+#			ifdef HAVE_ZIP
+				// see root/core/zip/src/RZip.cxx -> R__unzip
+				char method = is.get();
+				size_t chcdata = is.get();
+				chcdata |= (is.get() << 8);
+				chcdata |= (is.get() << 16);
+				size_t chdata = is.get();
+				chdata |= (is.get() << 8);
+				chdata |= (is.get() << 16);
+
+				if (chcdata == lcdata - lkey - 9 && chdata == ldata) {
+					if (complib == 1 && method == Z_DEFLATED) {
+						buffer = KeyBuffer{type, name, title, cycle, lkey, KeyBuffer::zlib,
+						                   pos + lkey + 9, chcdata, chdata, 0};
+					} else if (complib == 4 && method == LZ4_versionNumber() / 10000) {
+						buffer = KeyBuffer{type, name, title, cycle, lkey, KeyBuffer::lz4,
+						                   pos + lkey + 9 + 8, chcdata - 8, chdata, 0};
+					}
+				}
+#			endif
+			} else {
+				buffer = KeyBuffer{type, name, title, cycle, lkey, KeyBuffer::none,
+				                   pos + lkey, ldata, ldata, 0};
+			}
+			switch (buffer.type) {
+				case Basket:
+					basketkeys.emplace(pos, buffer);
 					break;
-				case 'I':
-					type = KeyBuffer::ContentType::Int;
+				case Tree:
+				case NTuple: {
+					auto it = treekeys.find(name);
+					if (it != treekeys.end()) {
+						// TTrees may be written several times, only consider last cycle
+						if (buffer.cycle > it->second.cycle) {
+							it->second = buffer;
+						}
+					} else
+						treekeys.emplace(name, buffer);
 					break;
-				case 'S':
-					type = KeyBuffer::ContentType::Short;
+				} case Streamer:
+					readStreamerInfo(buffer);
 					break;
-				case 'C':
-					type = KeyBuffer::ContentType::Byte;
+				case Double: case Float: case Int: case Short: case Byte:
+					histkeys.emplace(name + ';' + std::to_string(cycle), buffer);
 					break;
-				default:
-					type = KeyBuffer::ContentType::Invalid;
+				case Invalid: case Long: case Bool: case CString:
 					break;
 			}
-			if (type) {
-				std::string name(read<unsigned char>(is), 0);
-				is.read(&name[0], name.size());
-				std::string title(read<unsigned char>(is), 0);
-				is.read(&title[0], title.size());
-
-				auto it = histkeys.end();
-				// see root/io/io/src/TKey.cxx for reference
-				if (compression && ldata > 256) {
-#					ifdef HAVE_ZIP
-					// Default: compression level
-					// ZLIB: 100 + compression level
-					// LZ4:  400 + compression level
-					if (compression / 100 <= 1 || compression / 100 == 4) {
-						// see root/core/zip/src/RZip.cxx -> R__unzip
-						std::string lib(2, 0);
-						is.read(&lib[0], 2);
-						char method = is.get();
-						size_t chcdata = is.get();
-						chcdata |= (is.get() << 8);
-						chcdata |= (is.get() << 16);
-						size_t chdata = is.get();
-						chdata |= (is.get() << 8);
-						chdata |= (is.get() << 16);
-
-						if (chcdata == lcdata - lkey - 9 && chdata == ldata) {
-							if (lib == "ZL" && method == Z_DEFLATED) {
-								it = histkeys.emplace(name + ';' + std::to_string(cycle),
-								                      KeyBuffer{name, title, cycle, type, KeyBuffer::zlib,
-								                                pos + lkey + 9, chcdata, chdata, 0}
-								                     ).first;
-							} else if (lib == "L4" && method == LZ4_versionNumber() / (100 * 100)) {
-								it = histkeys.emplace(name + ';' + std::to_string(cycle),
-								                      KeyBuffer{name, title, cycle, type, KeyBuffer::lz4,
-								                                pos + lkey + 9 + 8, chcdata - 8, chdata, 0}
-								                     ).first;
-							}
-						}
-					}
-#					endif
-				} else {
-					it = histkeys.emplace(name + ';' + std::to_string(cycle),
-					                      KeyBuffer{name, title, cycle, type, KeyBuffer::none,
-					                                pos + lkey, ldata, ldata, 0}
-					                     ).first;
-				}
-				if (it != histkeys.end())
-					readNBins(it->second);
-			}
 		}
-		pos += (int)lcdata;
+		pos += lcdata;
+	}
+
+	// Create default object structures if no StreamerInfo was found.
+	// Obtained by running the following in ROOT with a file passed as an argument:
+	//
+	// _file0->GetStreamerInfoList()->Print()
+	//
+	// auto l = (TStreamerInfo*)_file0->GetStreamerInfoList()->At(ENTRYNUMBER);
+	// l->Print();
+	// for (int i=0; i<l->GetNelement(); ++i) {
+	//     auto e = l->GetElement(i);
+	//     e->Print();
+	//     cout << e->GetFullName() << " " << e->GetTypeName() << " " << e->GetSize() << endl;
+	// }
+
+	static const StreamerInfo dummyobject{"Object", 0, std::string(), false, false};
+	if (!treekeys.empty()) {
+		if (!streamerInfo.count("TTree")) {
+			streamerInfo["TTree"] = {dummyobject, dummyobject, dummyobject, dummyobject,
+			                         StreamerInfo{"fEntries", 8, std::string(), false, false},
+			                         StreamerInfo{std::string(), 5 * 8 + 4 * 4, std::string(), false, false},
+			                         StreamerInfo{"fNClusterRange", 4, std::string(), true, false},
+			                         StreamerInfo{std::string(), 6 * 8, std::string(), false, false},
+			                         StreamerInfo{"fNClusterRangeEnd", 8, "fNClusterRange", false, true},
+			                         StreamerInfo{"fNClusterSize", 8, "fNClusterRange", false, true},
+			                         StreamerInfo{"fBranches", 0, std::string(), false, false}
+			};
+		}
+		if (!streamerInfo.count("TBranch")) {
+			streamerInfo["TBranch"] = {StreamerInfo{"TNamed", 0, std::string(), false, false}, dummyobject,
+			                           StreamerInfo{std::string(), 3 * 4, std::string(), false, false},
+			                           StreamerInfo{"fWriteBasket", 4, std::string(), false, false},
+			                           StreamerInfo{std::string(), 8 + 4, std::string(), false, false},
+			                           StreamerInfo{"fMaxBaskets", 4, std::string(), true, false},
+			                           StreamerInfo{std::string(), 4 + 4 * 8, std::string(), false, false},
+			                           StreamerInfo{"fBranches", 0, std::string(), false, false},
+			                           StreamerInfo{"fLeaves", 0, std::string(), false, false},
+			                           StreamerInfo{"fBaskets", 0, std::string(), false, false},
+			                           StreamerInfo{"fBasketBytes", 4, "fMaxBaskets", false, true},
+			                           StreamerInfo{"fBasketEntry", 8, "fMaxBaskets", false, true},
+			                           StreamerInfo{"fBasketSeek", 8, "fMaxBaskets", false, true}
+			};
+		}
+	}
+	if (!histkeys.empty()) {
+		if (!streamerInfo.count("TH1")) {
+			streamerInfo["TH1"] = {dummyobject, dummyobject, dummyobject, dummyobject,
+			                       StreamerInfo{"fNcells", 4, std::string(), false, false},
+			                       StreamerInfo{"fXaxis", 0, std::string(), false, false},
+			                       StreamerInfo{"fYaxis", 0, std::string(), false, false},
+			                       StreamerInfo{"fZaxis", 0, std::string(), false, false},
+			                       StreamerInfo{std::string(), 2 * 2 + 8 * 8, std::string(), false, false},
+			                       dummyobject,
+			                       StreamerInfo{"fSumw2", 0, std::string(), false, false}};
+		}
+		if (!streamerInfo.count("TAxis")) {
+			streamerInfo["TAxis"] = {dummyobject, dummyobject,
+			                         StreamerInfo{"fNbins", 4, std::string(), false, false},
+			                         StreamerInfo{"fXmin", 8, std::string(), false, false},
+			                         StreamerInfo{"fXmax", 8, std::string(), false, false},
+			                         StreamerInfo{"fXbins", 0, std::string(), false, false}};
+		}
+	}
+
+	for (auto& tree : treekeys)
+		readNEntries(tree.second);
+	for (auto& hist : histkeys)
+		readNBins(hist.second);
+}
+
+void ROOTData::readNBins(ROOTData::KeyBuffer& kbuffer) {
+	std::string buffer = data(kbuffer);
+	if (!buffer.empty()) {
+		char* buf = &buffer[0];
+		std::map<std::string, size_t> counts;
+		Version(buf); // TH1(D/F/I/S/C)
+		Version(buf); // TH1
+		advanceTo(buf, streamerInfo.find("TH1")->second, std::string(), "fNcells", counts);
+		kbuffer.nrows = read<int>(buf); // fNcells
 	}
 }
 
-std::vector<std::string> ROOTHist::listHistograms() const {
+std::vector<std::string> ROOTData::listHistograms() const {
 	std::vector<std::string> l;
-	for (auto& n : histkeys)
+	for (auto& n : histkeys) {
 		l.emplace_back(n.first);
-
+	}
 	return l;
 }
 
-std::vector<ROOTHist::BinPars> ROOTHist::readHistogram(const std::string& name, int cycle) {
+std::vector<ROOTData::BinPars> ROOTData::readHistogram(const std::string& name, int cycle) {
 	auto it = histkeys.find(name + ';' + std::to_string(cycle));
 	if (it == histkeys.end())
-		return std::vector<ROOTHist::BinPars>();
+		return std::vector<ROOTData::BinPars>();
 
 	std::string buffer = data(it->second);
 	if (!buffer.empty()) {
-		// The object structure can be retrieved from TFile::GetStreamerInfoList().
-		// Every ROOT object contains a version number which may include the byte count
-		// for the object. The latter is currently assumed to be present to skip unused
-		// objects. No checks are performed. The corresponding ROOT code is quite nested
-		// but the actual readout is straight forward.
-		// Files for reference:
-		// root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
-		// root/core/cont/src/TArrayD.cxx -> Streamer
-		// root/hist/hist/src/TH1.cxx -> Streamer
-		char *buf = &buffer[0];
+		char* buf = &buffer[0];
+		std::map<std::string, size_t> counts;
+		auto& streamerTH1 = streamerInfo.find("TH1")->second;
+		auto& streamerTAxis = streamerInfo.find("TAxis")->second;
+
 		size_t count;
-		Version(buf, count); // TH1(D/F/I/S/C)
-		char* dbuf = buf + 4;
+		Version(buf); // TH1(D/F/I/S/C)
 		Version(buf, count); // TH1
-		dbuf += count;
-		Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
+		char* const dbuf = buf + count;
+		advanceTo(buf, streamerTH1, std::string(), "fNcells", counts);
 
 		std::vector<BinPars> r(read<int>(buf)); // fNcells
 		if (r.size() < 3)
 			return std::vector<BinPars>();
 
 		r.front().lowedge = -std::numeric_limits<double>::infinity();
 
+		advanceTo(buf, streamerTH1, "fNcells", "fXaxis", counts);
 		// x-Axis
-		char* nbuf = buf + 4;
 		Version(buf, count); // TAxis
-		nbuf += count;
-		Skip(buf, 2); // skip TNamed, TAttAxis
-
-		int nbins = read<int>(buf);
-		double xmin = read<double>(buf);
-		double xmax = read<double>(buf);
-		const size_t nborders = read<int>(buf);
-
+		char* const nbuf = buf + count;
+		advanceTo(buf, streamerTAxis, std::string(), "fNbins", counts);
+		const int nbins = read<int>(buf);
+		advanceTo(buf, streamerTAxis, "fNbins", "fXmin", counts);
+		const double xmin = read<double>(buf);
+		advanceTo(buf, streamerTAxis, "fXmin", "fXmax", counts);
+		const double xmax = read<double>(buf);
+		advanceTo(buf, streamerTAxis, "fXmax", "fXbins", counts);
+		const size_t nborders = read<int>(buf); // TArrayD
+		// root/core/cont/src/TArrayD.cxx -> Streamer
 		if (nborders == r.size() - 1) {
 			for (size_t i = 0; i < nborders; ++i) {
 				r[i + 1].lowedge = read<double>(buf);
@@ -563,81 +805,344 @@
 				r[i + 1].lowedge = static_cast<double>(i) * scale + xmin;
 			}
 		}
-		buf = nbuf;
-		Skip(buf, 2); // skip y-Axis and z-Axis;
-		buf += 68; // skip 2 shorts and 8 doubles
-		buf += read<int>(buf) * 8; // skip fContour array
+		buf = nbuf; // go beyond x-Axis
 
-		if (static_cast<size_t>(read<int>(buf)) == r.size()) {
+		advanceTo(buf, streamerTH1, "fXaxis", "fSumw2", counts);
+		if (static_cast<size_t>(read<int>(buf)) == r.size()) { // TArrayD
 			for (auto& b : r)
 				b.sumw2 = read<double>(buf); // always double
 		}
-
 		buf = dbuf; // skip to contents of TH1(D/F/I/S/C)
 
 		if (static_cast<size_t>(read<int>(buf)) == r.size()) {
-			switch (it->second.type) {
-				case KeyBuffer::ContentType::Double:
-					for (auto& b : r)
-						b.content = read<double>(buf);
-					break;
-				case KeyBuffer::ContentType::Float:
-					for (auto& b : r)
-						b.content = read<float>(buf);
-					break;
-				case KeyBuffer::ContentType::Int:
-					for (auto& b : r)
-						b.content = read<int>(buf);
-					break;
-				case KeyBuffer::ContentType::Short:
-					for (auto& b : r)
-						b.content = read<short>(buf);
-					break;
-				case KeyBuffer::ContentType::Byte:
-					for (auto& b : r)
-						b.content = read<char>(buf);
-					break;
-				case KeyBuffer::ContentType::Invalid: // never reached
-				default:
-					break;
-			}
+			auto readf = readType<double>(it->second.type);
+			for (auto& b : r)
+				b.content = readf(buf);
 		}
 
 		return r;
 	} else
 		return std::vector<BinPars>();
 }
 
-void ROOTHist::readNBins(ROOTHist::KeyBuffer& kbuffer) {
+void ROOTData::readNEntries(ROOTData::KeyBuffer& kbuffer) {
 	std::string buffer = data(kbuffer);
 	if (!buffer.empty()) {
-		// The object structure can be retrieved from TFile::GetStreamerInfoList().
-		// Every ROOT object contains a version number which may include the byte count
-		// for the object. The latter is currently assumed to be present to skip unused
-		// objects. No checks are performed. The corresponding ROOT code is quite nested
-		// but the actual readout is straight forward.
-		// Files for reference:
-		// root/io/io/src/TBufferFile.cxx -> ReadVersion, ReadTString, ReadObjectAny
-		// root/core/cont/src/TArrayD.cxx -> Streamer
-		// root/hist/hist/src/TH1.cxx -> Streamer
-		char *buf = &buffer[0];
+		char* buf = &buffer[0];
+		std::map<std::string, size_t> counts;
+		if (kbuffer.type == NTuple)
+			Version(buf); // TNtuple(D)
+		Version(buf); // TTree
+		advanceTo(buf, streamerInfo.find("TTree")->second, std::string(), "fEntries", counts);
+		kbuffer.nrows = read<long int>(buf); // fEntries
+	}
+}
+
+std::vector<std::string> ROOTData::listTrees() const {
+	std::vector<std::string> l;
+	for (auto& n : treekeys) {
+		l.emplace_back(n.first);
+	}
+	return l;
+}
+
+std::vector<ROOTData::LeafInfo> ROOTData::listLeaves(const std::string& treename) const {
+	std::vector<LeafInfo> leaves;
+
+	auto it = treekeys.find(treename);
+	if (it == treekeys.end())
+		return leaves;
+
+	std::ifstream is(filename, std::ifstream::binary);
+	std::string datastring = data(it->second, is);
+	if (datastring.empty())
+		return leaves;
+
+	char* buf = &datastring[0];
+	char* const buf0 = buf - it->second.keylength;
+	std::map<std::string, size_t> counts;
+	auto& streamerTBranch = streamerInfo.find("TBranch")->second;
+
+	if (it->second.type == NTuple)
+		Version(buf); // TNtuple(D)
+	Version(buf); // TTree
+	advanceTo(buf, streamerInfo.find("TTree")->second, std::string(), "fBranches", counts);
+
+	// read the list of branches
+	Version(buf); // TObjArray
+	SkipObject(buf);
+	String(buf);
+	const size_t nbranches = read<int>(buf);
+	const size_t lowb = read<int>(buf);
+	std::map<size_t, std::string> tags;
+	for (size_t i = 0; i < nbranches; ++i) {
+		std::string clname = readObject(buf, buf0, tags);
 		size_t count;
-		Version(buf, count); // TH1(D/F/I/S/C)
-		char* dbuf = buf + 4;
-		Version(buf, count); // TH1
-		dbuf += count;
-		Skip(buf, 4); // skip TNamed, TAttLine, TAttFill, TAttMarker
+		Version(buf, count); // TBranch or TBranchElement
+		char* const nbuf = buf + count;
+		if (i >= lowb) {
+			if (clname == "TBranchElement") {
+				Version(buf); // TBranch
+			}
+			advanceTo(buf, streamerTBranch, std::string(), "TNamed", counts);
+			Version(buf); // TNamed
+			SkipObject(buf);
+			const std::string branch = String(buf);
+			String(buf);
+			// TODO add reading of nested branches (fBranches)
+			advanceTo(buf, streamerTBranch, "TNamed", "fLeaves", counts);
+
+			// fLeaves
+			Version(buf); // TObjArray
+			SkipObject(buf);
+			String(buf);
+			const size_t nleaves = read<int>(buf);
+			const size_t lowb = read<int>(buf);
+			for (size_t i = 0; i < nleaves; ++i) {
+				std::string clname = readObject(buf, buf0, tags);
+				Version(buf, count); // TLeaf(D/F/B/S/I/L/C/O)
+				char* nbuf = buf + count;
+				if (i >= lowb && clname.size() == 6 && clname.compare(0, 5, "TLeaf") == 0) {
+					Version(buf); // TLeaf
+					Version(buf); // TNamed
+					SkipObject(buf);
+					const std::string leafname = String(buf);
+					const std::string leaftitle = String(buf);
+					size_t elements = read<int>(buf);
+					int bytes = read<int>(buf);
+					if ((leafType(clname.back()) & 0xF) != bytes)
+						qDebug() << "ROOTData: type " << clname.back() << " does not match its size!";
+					buf += 5;
+					leaves.emplace_back(LeafInfo{branch, leafname, leafType(clname.back()), !read<char>(buf), elements});
+				}
+
+				buf = nbuf;
+			}
+		}
 
-		kbuffer.nbins = read<int>(buf); // fNcells
+		buf = nbuf;
 	}
+	return leaves;
 }
 
-std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer) const {
+template<class T>
+std::vector<T> ROOTData::listEntries(const std::string& treename, const std::string& branchname, const std::string& leafname, const size_t element, const size_t nentries) const {
+	std::vector<T> entries;
+
+	auto it = treekeys.find(treename);
+	if (it == treekeys.end())
+		return entries;
+
+	std::ifstream is(filename, std::ifstream::binary);
+	std::string datastring = data(it->second, is);
+	if (datastring.empty())
+		return entries;
+
+	char* buf = &datastring[0];
+	char* const buf0 = buf - it->second.keylength;
+	std::map<std::string, size_t> counts;
+	auto& streamerTTree = streamerInfo.find("TTree")->second;
+	auto& streamerTBranch = streamerInfo.find("TBranch")->second;
+
+	if (it->second.type == NTuple)
+		Version(buf); // TNtuple(D)
+	Version(buf); // TTree
+	advanceTo(buf, streamerTTree, std::string(), "fEntries", counts);
+	entries.reserve(std::min(static_cast<size_t>(read<long int>(buf)), nentries)); // reserve space (maximum for number of entries)
+	advanceTo(buf, streamerTTree, "fEntries", "fBranches", counts);
+
+	// read the list of branches
+	Version(buf); // TObjArray
+	SkipObject(buf);
+	String(buf);
+	const size_t nbranches = read<int>(buf);
+	const size_t lowb = read<int>(buf);
+	std::map<size_t, std::string> tags;
+	for (size_t i = 0; i < nbranches; ++i) {
+		std::string clname = readObject(buf, buf0, tags);
+		size_t count;
+		Version(buf, count); // TBranch or TBranchElement
+		char* const nbuf = buf + count;
+		if (i >= lowb) {
+			if (clname == "TBranchElement") {
+				Version(buf);
+			}
+			Version(buf); // TNamed
+			SkipObject(buf);
+			const std::string currentbranch = String(buf);
+			String(buf);
+
+			advanceTo(buf, streamerTBranch, "TNamed", "fWriteBasket", counts);
+			int fWriteBasket = read<int>(buf);
+			// TODO add reading of nested branches (fBranches)
+			advanceTo(buf, streamerTBranch, "fWriteBasket", "fLeaves", counts);
+
+			// fLeaves
+			Version(buf); // TObjArray
+			SkipObject(buf);
+			String(buf);
+			const size_t nleaves = read<int>(buf);
+			const size_t lowb = read<int>(buf);
+			int leafoffset = 0, leafcount = 0, leafcontent = 0, leafsize = 0;
+			bool leafsign = false;
+            ContentType leaftype = Invalid;
+			for (size_t i = 0; i < nleaves; ++i) {
+				std::string clname = readObject(buf, buf0, tags);
+				Version(buf, count); // TLeaf(D/F/L/I/S/B/O/C/Element)
+				char* nbuf = buf + count;
+				if (currentbranch == branchname) {
+					if (i >= lowb && clname.size() >= 5 && clname.compare(0, 5, "TLeaf") == 0) {
+						Version(buf); // TLeaf
+						Version(buf); // TNamed
+						SkipObject(buf);
+						const bool istheleaf = (clname.size() == 6 && leafname == String(buf));
+						String(buf);
+						const int len = read<int>(buf);
+						const int size = read<int>(buf);
+						if (istheleaf) {
+							leafoffset = leafcount;
+							leafsize = size;
+							leaftype = leafType(clname.back());
+						}
+						leafcount += len * size;
+						if (istheleaf) {
+							leafcontent = leafcount - leafoffset;
+							buf += 1;
+							leafsign = !read<bool>(buf);
+						}
+					}
+				}
+
+				buf = nbuf;
+			}
+			if (leafcontent == 0) {
+				buf = nbuf;
+				continue;
+			}
+
+			if (static_cast<int>(element) * leafsize >= leafcontent) {
+				qDebug() << "ROOTData: " << leafname.c_str() << " only contains " << leafcontent / leafsize << " elements.";
+				break;
+			}
+
+			advanceTo(buf, streamerTBranch, "fLeaves", "fBaskets", counts);
+			// fBaskets (probably empty)
+			Version(buf, count); // TObjArray
+			char* const basketsbuf = buf += count + 1; // TODO there is one byte to be skipped in fBaskets, why is that?
+
+			advanceTo(buf, streamerTBranch, "fBaskets", "fBasketEntry", counts);
+			for (int i = 0; i <= fWriteBasket; ++i) {
+				if (static_cast<size_t>(read<long int>(buf)) > nentries) {
+					fWriteBasket = i;
+					break;
+				}
+			}
+			// rewind to the end of fBaskets and look for the fBasketSeek array
+			advanceTo(buf = basketsbuf, streamerTBranch, "fBaskets", "fBasketSeek", counts);
+			auto readf = readType<T>(leaftype, leafsign);
+			for (int i = 0; i < fWriteBasket; ++i) {
+				size_t pos = read<long int>(buf);
+				auto it = basketkeys.find(pos);
+				if (it != basketkeys.end()) {
+					std::string basketbuffer = data(it->second);
+					if (!basketbuffer.empty()) {
+						char* bbuf = &basketbuffer[0];
+						char* const bufend = bbuf + basketbuffer.size();
+						while (bbuf + leafcount <= bufend && entries.size() < nentries) {
+							bbuf += leafoffset + leafsize * element;
+							entries.emplace_back(readf(bbuf));
+							bbuf += leafcount - leafsize * (element + 1) - leafoffset;
+						}
+					}
+				} else {
+					qDebug() << "ROOTData: fBasketSeek(" << i << "): " << pos << " (not available)";
+				}
+			}
+		}
+
+		buf = nbuf;
+	}
+
+	return entries;
+}
+
+ROOTData::ContentType ROOTData::histType(const char type)
+{
+	switch (type) {
+		case 'D':
+			return Double;
+		case 'F':
+			return Float;
+		case 'I':
+			return Int;
+		case 'S':
+			return Short;
+		case 'C':
+			return Byte;
+		default:
+			return Invalid;
+	}
+}
+
+ROOTData::ContentType ROOTData::leafType(const char type)
+{
+	switch (type) {
+		case 'D':
+			return Double;
+		case 'F':
+			return Float;
+		case 'L':
+			return Long;
+		case 'I':
+			return Int;
+		case 'S':
+			return Short;
+		case 'B':
+			return Byte;
+		case 'O':
+			return Bool;
+		case 'C':
+			return CString;
+		default:
+			return Invalid;
+	}
+}
+
+template<class T>
+T (*ROOTData::readType(ROOTData::ContentType type, bool sign) const)(char*&)
+{
+	switch (type) {
+		case Double:
+			return readcast<double, T>;
+		case Float:
+			return readcast<float, T>;
+		case Long:
+			return sign ? readcast<long, T> : readcast<unsigned long, T>;
+		case Int:
+			return sign ? readcast<int, T> : readcast<unsigned int, T>;
+		case Short:
+			return sign ? readcast<short, T> : readcast<unsigned short, T>;
+		case Byte:
+			return sign ? readcast<char, T> : readcast<unsigned char, T>;
+		case Bool:
+			return readcast<bool, T>;
+		case CString:
+		case Tree:
+		case NTuple:
+		case Basket:
+		case Streamer:
+		case Invalid:
+			break;
+	}
+	return readcast<char, T>;
+}
+
+std::string ROOTData::data(const ROOTData::KeyBuffer& buffer) const {
 	std::ifstream is(filename, std::ifstream::binary);
 	return data(buffer, is);
 }
 
-std::string ROOTHist::data(const ROOTHist::KeyBuffer& buffer, std::ifstream& is) const {
+std::string ROOTData::data(const ROOTData::KeyBuffer& buffer, std::ifstream& is) const {
 	std::string data(buffer.count, 0);
 	is.seekg(buffer.start);
 	if (buffer.compression == KeyBuffer::none) {
@@ -661,7 +1166,159 @@
 	return std::string();
 }
 
-// needs to be after ROOTHistHelpers namespace declaration
+void ROOTData::readStreamerInfo(const ROOTData::KeyBuffer& buffer)
+{
+	std::ifstream is(filename, std::ifstream::binary);
+	std::string datastring = data(buffer, is);
+	if (!datastring.empty()) {
+		char* buf = &datastring[0];
+		char* const buf0 = buf - buffer.keylength;
+		Version(buf);
+		SkipObject(buf); // TCollection
+		String(buf);
+		const int nobj = read<int>(buf);
+		std::map<size_t, std::string> tags;
+		for (int i = 0; i < nobj; ++i) {
+			std::string clname = readObject(buf, buf0, tags);
+			size_t count;
+			Version(buf, count);
+			char* const nbuf = buf + count;
+			if (clname == "TStreamerInfo") {
+				Version(buf);
+				SkipObject(buf);
+				std::vector<StreamerInfo>& sinfo = streamerInfo[String(buf)];
+				String(buf);
+				buf += 8; // skip check sum and version
+
+				clname = readObject(buf, buf0, tags);
+				Version(buf, count);
+				if (clname != "TObjArray") {
+					buf += count;
+					continue;
+				}
+
+				SkipObject(buf); // TObjArray
+				String(buf);
+				const int nobj = read<int>(buf);
+				const int lowb = read<int>(buf);
+				for (int i = 0; i < nobj; ++i) {
+					std::string clname = readObject(buf, buf0, tags);
+					Version(buf, count);
+					char* const nbuf = buf + count;
+
+					const bool isbasicpointer = clname == "TStreamerBasicPointer";
+					const bool ispointer = isbasicpointer || clname == "TStreamerObjectPointer";
+					if (i >= lowb) {
+						if (ispointer ||
+						    clname == "TStreamerBase" ||
+						    clname == "TStreamerBasicType" ||
+						    clname == "TStreamerObject" ||
+						    clname == "TStreamerObjectAny" ||
+						    clname == "TStreamerString" ||
+						    clname == "TStreamerSTL")
+						{
+							Version(buf); // TStreamerXXX
+							Version(buf); // TStreamerElement
+							SkipObject(buf);
+							const std::string name = String(buf);
+							const std::string title = String(buf);
+							int type = read<int>(buf);
+							size_t size = read<int>(buf);
+
+							if (clname.compare(0, 15, "TStreamerObject") == 0)
+								size = 0;
+							std::string counter;
+							bool iscounter = false;
+							if (ispointer) {
+								if (!title.empty() && title.front() == '[') {
+									const size_t endref = title.find(']', 1);
+									if (endref != title.npos) {
+										counter = title.substr(1, endref - 1);
+									}
+								}
+								if (isbasicpointer) {
+									// see root/io/io/inc/TStreamerInfo.h -> TStreamerInfo::EReadWrite
+									switch(type - 40) {
+										case 1:  // char
+										case 11: // unsigned char
+											size = 1;
+											break;
+										case 2:  // short
+										case 12: // unsigned short
+										case 19: // float16
+											size = 2;
+											break;
+										case 3:  // int
+										case 5:  // float
+										case 9:  // double32
+										case 13: // unsigned int
+											size = 4;
+											break;
+										case 4:  // long
+										case 8:  // double
+										case 14: // unsigned long
+										case 16: // long
+										case 17: // unsigned long
+											size = 8;
+											break;
+									}
+								}
+							} else if (clname == "TStreamerBasicType") {
+								iscounter = type == 6; // see root/io/io/inc/TStreamerInfo.h -> TStreamerInfo::EReadWrite
+							}
+							sinfo.emplace_back(StreamerInfo{name, size, counter, iscounter, ispointer});
+						}
+					}
+					buf = nbuf;
+				}
+			} else
+				buf = nbuf;
+			buf += 1; // trailing zero of TObjArray*
+		}
+	} else
+		qDebug() << "ROOTData: Inflation failed!";
+}
+
+bool ROOTData::advanceTo(char*& buf, const std::vector<ROOTData::StreamerInfo>& objects, const std::string& current, const std::string& target, std::map<std::string, size_t>& counts)
+{
+	// The object structure can be retrieved from TFile::GetStreamerInfoList().
+	// Every ROOT object contains a version number which may include the byte count
+	// for the object. The latter is currently assumed to be present to skip unused
+	// objects. No checks are performed. The corresponding ROOT code is quite nested
+	// but the actual readout is straight forward.
+	auto it = objects.begin();
+	if (!current.empty()) {
+		for (; it != objects.end(); ++it) {
+			if (it->name == target) {
+				return false; // target lies before current buffer position
+			} else if (it->name == current) {
+				++it;
+				break;
+			}
+		}
+	}
+
+	for (; it != objects.end(); ++it) {
+		if (it->name == target)
+			return true;
+
+		if (it->size == 0)
+			Skip(buf, 1);
+		else if (it->iscounter)
+			counts[it->name] = read<int>(buf);
+		else if (it->ispointer) {
+			if (it->counter.empty())
+				buf += it->size + 1;
+			else
+				buf += it->size * counts[it->counter] + 1;
+		} else
+			buf += it->size;
+	}
+
+	return false;
+}
+
+// needs to be after ROOTDataHelpers namespace declaration
 
 QString ROOTFilter::fileInfoString(const QString& fileName) {
 	DEBUG("ROOTFilter::fileInfoString()");
@@ -676,16 +1333,16 @@
 		return i18n("Not a ROOT file");
 	}
 
-	int version = ROOTHistHelpers::read<int>(is);
+	int version = read<int>(is);
 
 	info += i18n("File format version: %1", QString::number(version));
 	info += QLatin1String("<br>");
 
 	is.seekg(20);
-	int freeBytes = ROOTHistHelpers::read<int>(is);
-	int freeRecords = ROOTHistHelpers::read<int>(is);
-	int namedBytes = ROOTHistHelpers::read<int>(is);
-	char pointerBytes = ROOTHistHelpers::read<char>(is);
+	int freeBytes = read<int>(is);
+	int freeRecords = read<int>(is);
+	int namedBytes = read<int>(is);
+	char pointerBytes = read<char>(is);
 	info += i18n("FREE data record size: %1 bytes", QString::number(freeBytes));
 	info += QLatin1String("<br>");
 	info += i18n("Number of free data records: %1", QString::number(freeRecords));
@@ -695,13 +1352,13 @@
 	info += i18n("Size of file pointers: %1 bytes", QString::number(pointerBytes));
 	info += QLatin1String("<br>");
 
-	int compression = ROOTHistHelpers::read<int>(is);
+	int compression = read<int>(is);
 	compression = compression > 0 ? compression : 0;
 	info += i18n("Compression level and algorithm: %1", QString::number(compression));
 	info += QLatin1String("<br>");
 
 	is.seekg(41);
-	int infoBytes = ROOTHistHelpers::read<int>(is);
+	int infoBytes = read<int>(is);
 	info += i18n("Size of TStreamerInfo record: %1 bytes", QString::number(infoBytes));
 	info += QLatin1String("<br>");
 
diff --git a/src/backend/datasources/filters/ROOTFilterPrivate.h b/src/backend/datasources/filters/ROOTFilterPrivate.h
--- a/src/backend/datasources/filters/ROOTFilterPrivate.h
+++ b/src/backend/datasources/filters/ROOTFilterPrivate.h
@@ -28,7 +28,6 @@
 #ifndef ROOTFILTERPRIVATE_H
 #define ROOTFILTERPRIVATE_H
 
-#include <QMap>
 #include <QString>
 #include <QStringList>
 #include <QVector>
@@ -44,31 +43,94 @@
 class AbstractColumn;
 
 /**
- * @brief Read TH1 histograms from ROOT files without depending on ROOT libraries
+ * @brief Read TH1 histograms and TTrees from ROOT files without depending on ROOT libraries
  */
-class ROOTHist {
+class ROOTData
+ {
 public:
 	/**
-	 * @brief Open ROOT file and save file positions of histograms
+	 * @brief Open ROOT file and save file positions of histograms and trees
 	 *
 	 * Also checks for the compression level. Currently the default ZLIB and LZ4 compression
-	 * types are supported. The TH1 object structure is hard coded, TStreamerInfo is not read.
+	 * types are supported. The TStreamerInfo is read if it is available, otherwise the
+     * data structure as of ROOT v6.15 is used. No tests were performed with data written
+     * prior to ROOT v5.34.
 	 *
 	 * @param[in] filename ROOT file to be read
 	 */
-	explicit ROOTHist(const std::string& filename);
+	explicit ROOTData (const std::string& filename);
 
+    /// Parameters to describe a bin
 	struct BinPars {
 		double content;
 		double sumw2;
 		double lowedge;
 	};
 
+	/**
+	 * @brief Identifiers for different data types
+	 *
+	 * Histograms are identified by their bin type. The lowest byte indicates the size
+	 * of the numeric types for cross checks during the import.
+	 */
+	enum ContentType {Invalid = 0, Tree = 0x10, NTuple = 0x11, Basket = 0x20,
+	                  Streamer = 0x30,
+	                  Double = 0x48, Float = 0x54,
+	                  Long = 0x68, Int = 0x74, Short = 0x82, Byte = 0x91,
+	                  Bool = 0xA1, CString = 0xB0};
+
+	/// Information about leaf contents
+	struct LeafInfo {
+		std::string branch;
+		std::string leaf;
+		ContentType type;
+		bool issigned;
+		size_t elements;
+	};
+
 	/**
 	 * @brief List available histograms in the ROOT file
 	 */
 	std::vector<std::string> listHistograms() const;
 
+	/**
+	 * @brief List available trees in the ROOT file
+	 */
+	std::vector<std::string> listTrees() const;
+
+	/**
+	 * @brief List information about data contained in leaves
+	 *
+	 * @param[in] treename Name of the tree
+	 */
+	std::vector<LeafInfo> listLeaves(const std::string& treename) const;
+
+	/**
+	 * @brief Get entries of a leaf
+	 *
+	 * @param[in] treename Name of the tree
+	 * @param[in] branchname Name of the branch
+	 * @param[in] leafname Name of the leaf
+	 * @param[in] element Index, if leaf is an array
+	 * @param[in] nentries Maximum number of entries to be read
+	 */
+	template<typename T>
+	std::vector<T> listEntries(const std::string& treename, const std::string& branchname, const std::string& leafname,
+	                           const size_t element = 0, const size_t nentries = std::numeric_limits<size_t>::max()) const;
+	/**
+	 * @brief Get entries of a leaf with the same name as its branch
+	 *
+	 * @param[in] treename Name of the tree
+	 * @param[in] branchname Name of the branch
+	 * @param[in] nentries Maximum number of entries to be read
+	 */
+	template<typename T>
+	std::vector<T> listEntries(const std::string& treename, const std::string& branchname,
+	                           const size_t element = 0, const size_t nentries = std::numeric_limits<size_t>::max()) const
+	{
+		return listEntries<T>(treename, branchname, branchname, element, nentries);
+	}
+
 	/**
 	 * @brief Read histogram from file
 	 *
@@ -90,7 +152,7 @@
 	 */
 	std::string histogramTitle(const std::string& name, int cycle = 1)
 	{
-		auto it = histkeys.find(name + ";" + std::to_string(cycle));
+		auto it = histkeys.find(name + ';' + std::to_string(cycle));
 		if (it != histkeys.end())
 			return it->second.title;
 		else
@@ -107,35 +169,87 @@
 	 */
 	int histogramBins(const std::string& name, int cycle = 1)
 	{
-		auto it = histkeys.find(name + ";" + std::to_string(cycle));
+		auto it = histkeys.find(name + ';' + std::to_string(cycle));
 		if (it != histkeys.end())
-			return it->second.nbins;
+			return it->second.nrows;
+		else
+			return 0;
+	}
+
+	/**
+	 * @brief Get number of entries in tree
+	 *
+	 * The number of entriees is stored in the buffer. No file access required.
+	 *
+	 * @param[in] name Tree name
+	 */
+	int treeEntries(const std::string& name)
+	{
+		auto it = treekeys.find(name);
+		if (it != treekeys.end())
+			return it->second.nrows;
 		else
 			return 0;
 	}
 private:
 	struct KeyBuffer {
+		ContentType type;
 		std::string name;
 		std::string title;
 		int cycle;
-		enum ContentType { Invalid = 0, Double, Float, Int, Short, Byte } type;
+		size_t keylength;
 		enum CompressionType { none, zlib, lz4 } compression;
 		size_t start;
 		size_t compressed_count;
 		size_t count;
-		int nbins;
+		int nrows;
 	};
 
-	/// Get the number of bins contained in the histogram
-	void readNBins(ROOTHist::KeyBuffer& buffer);
+	struct StreamerInfo
+	{
+		std::string name;
+		size_t size;
+		std::string counter;
+		bool iscounter;
+		bool ispointer;
+	};
+
+	/// Get data type from histogram identifier
+	static ContentType histType(const char type);
+	/// Get data type from leaf identifier
+	static ContentType leafType(const char type);
+	/// Get function to read a buffer of the specified type
+	template<class T>
+	T (*readType(ContentType type, bool sign = true) const)(char*&);
+
+	/// Get the number of bins contained in a histogram
+	void readNBins(KeyBuffer& buffer);
+	/// Get the number of entries contained in a tree
+	void readNEntries(KeyBuffer& buffer);
 	/// Get buffer from file content at histogram position
-	std::string data(const ROOTHist::KeyBuffer& buffer) const;
+	std::string data(const KeyBuffer& buffer) const;
 	/// Get buffer from file content at histogram position, uses already opened stream
-	std::string data(const ROOTHist::KeyBuffer& buffer, std::ifstream& is) const;
+	std::string data(const KeyBuffer& buffer, std::ifstream& is) const;
+	/// Load streamer information
+	void readStreamerInfo(const KeyBuffer& buffer);
+	/**
+	 * @brief Advance to an object inside a class according to streamer information
+	 *
+	 * The number of entriees is stored in the buffer. No file access required.
+	 *
+	 * @param[in] buf Pointer to the current position in the class object
+	 * @param[in] objects A list of objects in the class defined by the streamer information
+	 * @param[in] current The name of the current object
+	 * @param[in] target The name of the object to be advanced to
+	 * @param[in] counts A list of the number of entries in objects of dynamic length; updated while reading
+	 */
+	static bool advanceTo(char*& buf, const std::vector<StreamerInfo>& objects, const std::string& current, const std::string& target, std::map<std::string, size_t>& counts);
 
 	std::string filename;
-	std::map<std::string, KeyBuffer> histkeys;
-	int compression;
+	std::map<std::string, KeyBuffer> histkeys, treekeys;
+	std::map<size_t, KeyBuffer> basketkeys;
+
+	std::map<std::string, std::vector<StreamerInfo> > streamerInfo;
 };
 
 class ROOTFilterPrivate {
@@ -155,34 +269,38 @@
 
 	/// List names of histograms contained in ROOT file
 	QStringList listHistograms(const QString& fileName);
+	/// List names of trees contained in ROOT file
+	QStringList listTrees(const QString& fileName);
+	/// List names of leaves contained in ROOT tree
+	QVector<QStringList> listLeaves(const QString& fileName, const QString& treeName);
 
 	/// Get preview data of the currently set histogram
-	QVector<QStringList> previewCurrentHistogram(const QString& fileName,
+	QVector<QStringList> previewCurrentObject(const QString& fileName,
 	                                             int first, int last);
 
 	/// Get the number of bins in the current histogram
-	int binsInCurrentHistogram(const QString& fileName);
+	int rowsInCurrentObject(const QString& fileName);
 
 	/// Identifier of the current histogram
-	QString currentHistogram;
-	/// Start bin to read (can be -1, skips the underflow bin 0)
-	int startBin = -1;
-	/// End bin to read (can be -1, skips the overflow bin)
-	int endBin = -1;
+	QString currentObject;
+	/// First row to read (can be -1, skips the underflow bin 0)
+	int startRow = -1;
+	/// Last row to read (can be -1, skips the overflow bin)
+	int endRow = -1;
 	/// Start column to read
-	int columns = 0;
+	QVector<QStringList> columns;
 private:
-	/// Create headers from set columns
-	QStringList createHeaders();
 	/// Checks and updates the current ROOT file path
 	void setFile(const QString& fileName);
 	/// Calls ReadHistogram from ROOTHist
-	std::vector<ROOTHist::BinPars> readHistogram();
+	std::vector<ROOTData::BinPars> readHistogram(const QString& histName);
+	/// Calls listEntries from ROOTHist
+	std::vector<double> readTree(const QString& treeName, const QString& branchName, const QString& leafName, int element, int last);
 
 	/// Currently set ROOT file path
 	QString currentFile;
 	/// ROOTHist instance kept alive while currentFile does not change
-	std::unique_ptr<ROOTHist> currentROOTHist;
+	std::unique_ptr<ROOTData> currentROOTData;
 };
 
 #endif
diff --git a/src/kdefrontend/datasources/ImportFileDialog.cpp b/src/kdefrontend/datasources/ImportFileDialog.cpp
--- a/src/kdefrontend/datasources/ImportFileDialog.cpp
+++ b/src/kdefrontend/datasources/ImportFileDialog.cpp
@@ -283,7 +283,7 @@
 						static_cast<NetCDFFilter*>(filter)->setCurrentVarName(names[i]);
 						break;
 					case AbstractFileFilter::ROOT:
-						static_cast<ROOTFilter*>(filter)->setCurrentHistogram(names[i]);
+						static_cast<ROOTFilter*>(filter)->setCurrentObject(names[i]);
 						break;
 					case AbstractFileFilter::Ascii:
 					case AbstractFileFilter::Binary:
diff --git a/src/kdefrontend/datasources/ImportFileWidget.cpp b/src/kdefrontend/datasources/ImportFileWidget.cpp
--- a/src/kdefrontend/datasources/ImportFileWidget.cpp
+++ b/src/kdefrontend/datasources/ImportFileWidget.cpp
@@ -124,7 +124,7 @@
 #endif
 		ui.cbFileType->addItem(i18n("JSON data"), AbstractFileFilter::JSON);
 #ifdef HAVE_ZIP
-		ui.cbFileType->addItem(i18n("ROOT (CERN) Histograms"), AbstractFileFilter::ROOT);
+		ui.cbFileType->addItem(i18n("ROOT (CERN)"), AbstractFileFilter::ROOT);
 #endif
 		ui.cbFileType->addItem(i18n("Ngspice RAW ASCII"), AbstractFileFilter::NgspiceRawAscii);
 		ui.cbFileType->addItem(i18n("Ngspice RAW Binary"), AbstractFileFilter::NgspiceRawBinary);
@@ -704,10 +704,10 @@
 		auto filter = static_cast<ROOTFilter*>(m_currentFilter.get());
 		QStringList names = selectedROOTNames();
 		if (!names.isEmpty())
-			filter->setCurrentHistogram(names.first());
+			filter->setCurrentObject(names.first());
 
-		filter->setStartBin( m_rootOptionsWidget->startBin() );
-		filter->setEndBin( m_rootOptionsWidget->endBin() );
+		filter->setStartRow( m_rootOptionsWidget->startRow() );
+		filter->setEndRow( m_rootOptionsWidget->endRow() );
 		filter->setColumns( m_rootOptionsWidget->columns() );
 
 		break;
@@ -1918,13 +1918,12 @@
 	case AbstractFileFilter::ROOT: {
 		auto filter = static_cast<ROOTFilter*>(currentFileFilter());
 		lines = m_rootOptionsWidget->lines();
-
-		m_rootOptionsWidget->setNBins(filter->binsInCurrentHistogram(fileName));
-		importedStrings = filter->previewCurrentHistogram(
+		m_rootOptionsWidget->setNRows(filter->rowsInCurrentObject(fileName));
+		importedStrings = filter->previewCurrentObject(
 					fileName,
-					m_rootOptionsWidget->startBin(),
-					qMin(m_rootOptionsWidget->startBin() + m_rootOptionsWidget->lines() - 1,
-						 m_rootOptionsWidget->endBin())
+					m_rootOptionsWidget->startRow(),
+					qMin(m_rootOptionsWidget->startRow() + m_rootOptionsWidget->lines() - 1,
+						 m_rootOptionsWidget->endRow())
 					);
 		tmpTableWidget = m_rootOptionsWidget->previewWidget();
 		// the last vector element contains the column names
diff --git a/src/kdefrontend/datasources/ROOTOptionsWidget.h b/src/kdefrontend/datasources/ROOTOptionsWidget.h
--- a/src/kdefrontend/datasources/ROOTOptionsWidget.h
+++ b/src/kdefrontend/datasources/ROOTOptionsWidget.h
@@ -45,19 +45,24 @@
 	/// Return a list of selected histograms
 	const QStringList selectedROOTNames() const;
 	int lines() const { return ui.sbPreviewLines->value(); }
-	int startBin() const { return ui.sbFirst->value(); }
-	int endBin() const { return ui.sbLast->value(); }
-	int columns() const;
-	void setNBins(int nbins);
+	int startRow() const { return ui.sbFirst->value(); }
+	int endRow() const { return ui.sbLast->value(); }
+	QVector<QStringList> columns() const;
+	void setNRows(int nrows);
 	QTableWidget* previewWidget() const { return ui.twPreview; }
 
 private:
 	Ui::ROOTOptionsWidget ui;
+	QTreeWidgetItem* histItem;
+	QTreeWidgetItem* treeItem;
+	QHash<QString, QVector<QStringList> > leaves;
+
 	ImportFileWidget* m_fileWidget;
+	bool histselected = false;
 
 private slots:
 	/// Updates the selected data set of a ROOT file when a new item is selected
-	void rootListWidgetSelectionChanged();
+	void rootObjectSelectionChanged();
 };
 
 #endif
diff --git a/src/kdefrontend/datasources/ROOTOptionsWidget.cpp b/src/kdefrontend/datasources/ROOTOptionsWidget.cpp
--- a/src/kdefrontend/datasources/ROOTOptionsWidget.cpp
+++ b/src/kdefrontend/datasources/ROOTOptionsWidget.cpp
@@ -34,65 +34,152 @@
 
 ROOTOptionsWidget::ROOTOptionsWidget(QWidget* parent, ImportFileWidget* fileWidget) : QWidget(parent), m_fileWidget(fileWidget) {
 	ui.setupUi(parent);
+	histItem = new QTreeWidgetItem(ui.twContent, QStringList(i18n("Histograms")));
+	histItem->setFlags(Qt::ItemIsEnabled);
+	treeItem = new QTreeWidgetItem(ui.twContent, QStringList(i18n("Trees and Tuples")));
+	treeItem->setFlags(Qt::ItemIsEnabled);
 
-	connect(ui.lwContent, &QListWidget::itemSelectionChanged, this, &ROOTOptionsWidget::rootListWidgetSelectionChanged);
+	connect(ui.twContent, &QTreeWidget::itemSelectionChanged, this, &ROOTOptionsWidget::rootObjectSelectionChanged);
 	connect(ui.bRefreshPreview, &QPushButton::clicked, fileWidget, &ImportFileWidget::refreshPreview);
 }
 
 void ROOTOptionsWidget::clear() {
-	ui.lwContent->clear();
+	qDeleteAll(histItem->takeChildren());
+	qDeleteAll(treeItem->takeChildren());
 	ui.twPreview->clearContents();
 }
 
 void ROOTOptionsWidget::updateContent(ROOTFilter *filter, const QString& fileName) {
 	DEBUG("updateContent()");
-	ui.lwContent->clear();
-	ui.lwContent->addItems(filter->listHistograms(fileName));
+
+	qDeleteAll(histItem->takeChildren());
+	qDeleteAll(treeItem->takeChildren());
+	leaves.clear();
+	for (const QString& s : filter->listHistograms(fileName))
+		new QTreeWidgetItem(histItem, QStringList(s));
+	for (const QString& s : filter->listTrees(fileName)) {
+		new QTreeWidgetItem(treeItem, QStringList(s));
+		leaves[s] = filter->listLeaves(fileName, s);
+	}
 }
 
-void ROOTOptionsWidget::rootListWidgetSelectionChanged() {
-	DEBUG("rootListWidgetSelectionChanged()");
-	auto items = ui.lwContent->selectedItems();
+void ROOTOptionsWidget::rootObjectSelectionChanged() {
+	DEBUG("rootObjectSelectionChanged()");
+	auto items = ui.twContent->selectedItems();
 	QDEBUG("SELECTED ITEMS =" << items);
 
+	ui.twColumns->clear();
+
 	if (items.isEmpty())
 		return;
 
+	QTreeWidgetItem* const p = items.first()->parent();
+	if (p == histItem) {
+		ui.twColumns->setColumnCount(1);
+
+		auto center = new QTreeWidgetItem(ui.twColumns, QStringList(i18n("Bin Center")));
+		center->setData(0, Qt::UserRole, QStringList(QStringLiteral("center")));
+		center->setSelected(true);
+		center->setFirstColumnSpanned(true);
+		auto low = new QTreeWidgetItem(ui.twColumns, QStringList(i18n("Low Edge")));
+		low->setData(0, Qt::UserRole, QStringList(QStringLiteral("low")));
+		low->setFirstColumnSpanned(true);
+		auto content = new QTreeWidgetItem(ui.twColumns, QStringList(i18n("Content")));
+		content->setData(0, Qt::UserRole, QStringList(QStringLiteral("content")));
+		content->setSelected(true);
+		content->setFirstColumnSpanned(true);
+		auto error = new QTreeWidgetItem(ui.twColumns, QStringList(i18n("Error")));
+		error->setData(0, Qt::UserRole, QStringList(QStringLiteral("error")));
+		error->setSelected(true);
+		error->setFirstColumnSpanned(true);
+
+		if (!histselected) {
+			histselected = true;
+			ui.sbFirst->setMaximum(0);
+			ui.sbLast->setMaximum(0);
+		}
+	} else if (p == treeItem) {
+		ui.twColumns->setColumnCount(2);
+
+		for (const auto& l : leaves[items.first()->text(0)]) {
+			auto leaf = new QTreeWidgetItem(ui.twColumns, l);
+			bool ok = false;
+			if (l.count() > 1) {
+				QString index(l.back());
+				if (index.front() == '[' && index.back() == ']') {
+					size_t elements = index.mid(1, index.length() - 2).toUInt(&ok);
+					if (ok) {
+						leaf->setFlags(Qt::ItemIsEnabled);
+						QStringList elname({l.at(l.count() - 2), QString()});
+						QStringList eldata(elname);
+						if (l.count() > 2)
+							eldata.prepend(l.front());
+						for (size_t i = 0; i < elements; ++i) {
+							eldata.last() = elname.last() = QString("[%1]").arg(i);
+							auto el = new QTreeWidgetItem(leaf, elname);
+							el->setData(0, Qt::UserRole, eldata);
+						}
+					}
+				}
+			} else
+				leaf->setFirstColumnSpanned(true);
+
+			if (!ok) {
+				leaf->setData(0, Qt::UserRole, l);
+			}
+		}
+		if (histselected) {
+			histselected = false;
+			ui.sbFirst->setMaximum(0);
+			ui.sbLast->setMaximum(0);
+		}
+	}
+
 	m_fileWidget->refreshPreview();
 }
 
 const QStringList ROOTOptionsWidget::selectedROOTNames() const {
 	QStringList names;
 
-	for (const QListWidgetItem* const item : ui.lwContent->selectedItems())
-		names << item->text();
+	for (const QTreeWidgetItem* const item : ui.twContent->selectedItems()) {
+		if (item->parent() == histItem)
+			names << QStringLiteral("Hist:") + item->text(0);
+		else if (item->parent() == treeItem)
+			names << QStringLiteral("Tree:") + item->text(0);
+	}
 
 	return names;
 }
 
-int ROOTOptionsWidget::columns() const {
-	int cols = ui.checkCenter->isChecked() ? ROOTFilter::Center : 0;
-	cols |= ui.checkLow->isChecked() ? ROOTFilter::Low : 0;
-	cols |= ui.checkContent->isChecked() ? ROOTFilter::Content : 0;
-	cols |= ui.checkError->isChecked() ? ROOTFilter::Error : 0;
+QVector<QStringList> ROOTOptionsWidget::columns() const {
+	QVector<QStringList> cols;
+
+	auto item = ui.twColumns->topLevelItem(0);
+	while (item) {
+		if (item->isSelected()) {
+			cols << item->data(0,Qt::UserRole).toStringList();
+		}
+		item = ui.twColumns->itemBelow(item);
+	}
 
 	return cols;
 }
 
-void ROOTOptionsWidget::setNBins(int nbins) {
+void ROOTOptionsWidget::setNRows(int nrows) {
 	// try to retain the range settings:
-	// - if nbins was not 0, keep start bin,
+	// - if nrows was not 0, keep start row,
 	//   else set it to one after underflow
-	// - if nbins didn't change, keep end bin,
+	// - if nrows didn't change, keep end row,
 	//   else set it to one before overflow
-	const int max = qMax(nbins - 1, 0);
+	const int max = qMax(nrows - 1, 0);
 	int firstval = ui.sbFirst->value();
 	if (ui.sbFirst->maximum() == 0)
-		firstval = qMin(nbins - 1, 1);
+		firstval = qMin(nrows - 1, histselected ? 1 : 0);
 	ui.sbFirst->setMaximum(max);
 	ui.sbFirst->setValue(firstval);
 
-	int lastval = max == ui.sbLast->maximum() ? ui.sbLast->value() : qMax(max - 1, 0);
+	int lastval = max == ui.sbLast->maximum() ? ui.sbLast->value()
+	                                          : qMax(max - (histselected ? 1 : 0), 0);
 	ui.sbLast->setMaximum(max);
 	ui.sbLast->setValue(lastval);
 }
diff --git a/src/kdefrontend/ui/datasources/rootoptionswidget.ui b/src/kdefrontend/ui/datasources/rootoptionswidget.ui
--- a/src/kdefrontend/ui/datasources/rootoptionswidget.ui
+++ b/src/kdefrontend/ui/datasources/rootoptionswidget.ui
@@ -6,190 +6,176 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>516</width>
+    <width>702</width>
     <height>242</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
-    <layout class="QHBoxLayout" name="hlPreviewSetup">
-     <item>
-      <widget class="QLabel" name="labelPreview">
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="QTreeWidget" name="twContent">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+        <horstretch>1</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+      <property name="toolTip">
+       <string>Shows the content of the selected ROOT file</string>
+      </property>
+      <property name="selectionMode">
+       <enum>QAbstractItemView::SingleSelection</enum>
+      </property>
+      <attribute name="headerVisible">
+       <bool>false</bool>
+      </attribute>
+      <column>
        <property name="text">
-        <string>Number of bins to preview:</string>
+        <string notr="true">1</string>
        </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QSpinBox" name="sbPreviewLines">
-       <property name="minimum">
-        <number>1</number>
-       </property>
-       <property name="maximum">
-        <number>10000</number>
-       </property>
-       <property name="value">
-        <number>100</number>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QPushButton" name="bRefreshPreview">
-       <property name="text">
-        <string>Refresh</string>
-       </property>
-       <property name="icon">
-        <iconset theme="view-refresh"/>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="hlDataSelection">
-     <item>
-      <widget class="QLabel" name="labelData">
-       <property name="text">
-        <string>Data to import:</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <layout class="QGridLayout" name="glColumns">
-       <item row="0" column="1">
-        <widget class="QCheckBox" name="checkCenter">
-         <property name="text">
-          <string>Bin Center</string>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="2">
-        <widget class="QCheckBox" name="checkError">
-         <property name="text">
-          <string>Error</string>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
+      </column>
+     </widget>
+     <widget class="QWidget" name="vlSelectiontWidget">
+      <layout class="QVBoxLayout" name="vlSelection" stretch="0,0">
+       <item>
+        <widget class="QTreeWidget" name="twColumns">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
          </property>
-        </widget>
-       </item>
-       <item row="0" column="2">
-        <widget class="QCheckBox" name="checkLow">
-         <property name="text">
-          <string>Low Edge</string>
+         <property name="selectionMode">
+          <enum>QAbstractItemView::MultiSelection</enum>
          </property>
+         <attribute name="headerVisible">
+          <bool>false</bool>
+         </attribute>
+         <column>
+          <property name="text">
+           <string notr="true">1</string>
+          </property>
+         </column>
         </widget>
        </item>
-       <item row="1" column="1">
-        <widget class="QCheckBox" name="checkContent">
-         <property name="text">
-          <string>Content</string>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
-         </property>
-        </widget>
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout">
+         <item>
+          <widget class="QLabel" name="labelFirst">
+           <property name="text">
+            <string>First row:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="sbFirst">
+           <property name="maximum">
+            <number>100</number>
+           </property>
+           <property name="value">
+            <number>1</number>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QLabel" name="labelLast">
+           <property name="text">
+            <string>Last row:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="sbLast">
+           <property name="maximum">
+            <number>100</number>
+           </property>
+           <property name="value">
+            <number>99</number>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </item>
       </layout>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer_2">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <layout class="QGridLayout" name="glBins">
-       <item row="0" column="1">
-        <widget class="QSpinBox" name="sbFirst">
-         <property name="maximum">
-          <number>100</number>
-         </property>
-         <property name="value">
-          <number>1</number>
-         </property>
-        </widget>
+     </widget>
+     <widget class="QWidget" name="vlPreviewWidget">
+      <layout class="QVBoxLayout" name="vlPreview" stretch="5,0">
+       <item>
+        <layout class="QHBoxLayout" name="hlPreviewSetup">
+         <item>
+          <widget class="QLabel" name="labelPreview">
+           <property name="text">
+            <string>Number of rows to preview:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QSpinBox" name="sbPreviewLines">
+           <property name="minimum">
+            <number>1</number>
+           </property>
+           <property name="maximum">
+            <number>10000</number>
+           </property>
+           <property name="value">
+            <number>100</number>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QPushButton" name="bRefreshPreview">
+           <property name="text">
+            <string>Refresh</string>
+           </property>
+           <property name="icon">
+            <iconset theme="view-refresh">
+             <normaloff>.</normaloff>.</iconset>
+           </property>
+          </widget>
+         </item>
+        </layout>
        </item>
-       <item row="1" column="1">
-        <widget class="QSpinBox" name="sbLast">
-         <property name="maximum">
-          <number>100</number>
+       <item>
+        <widget class="QTableWidget" name="twPreview">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
          </property>
-         <property name="value">
-          <number>99</number>
-         </property>
-        </widget>
-       </item>
-       <item row="0" column="0">
-        <widget class="QLabel" name="labelFirst">
-         <property name="text">
-          <string>First Bin:</string>
-         </property>
-        </widget>
-       </item>
-       <item row="1" column="0">
-        <widget class="QLabel" name="labelLast">
-         <property name="text">
-          <string>Last Bin:</string>
+         <property name="editTriggers">
+          <set>QAbstractItemView::NoEditTriggers</set>
          </property>
+         <attribute name="horizontalHeaderVisible">
+          <bool>true</bool>
+         </attribute>
+         <attribute name="verticalHeaderVisible">
+          <bool>false</bool>
+         </attribute>
         </widget>
        </item>
       </layout>
-     </item>
-    </layout>
+     </widget>
+    </widget>
    </item>
    <item>
-    <layout class="QHBoxLayout" name="hlPreview">
-     <item>
-      <widget class="QSplitter" name="splitter">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <widget class="QListWidget" name="lwContent">
-        <property name="toolTip">
-         <string>Shows the content of the selected ROOT file</string>
-        </property>
-        <property name="selectionMode">
-         <enum>QAbstractItemView::ExtendedSelection</enum>
-        </property>
-       </widget>
-       <widget class="QTableWidget" name="twPreview">
-        <property name="editTriggers">
-         <set>QAbstractItemView::NoEditTriggers</set>
-        </property>
-        <attribute name="horizontalHeaderVisible">
-         <bool>true</bool>
-        </attribute>
-        <attribute name="verticalHeaderVisible">
-         <bool>false</bool>
-        </attribute>
-       </widget>
-      </widget>
-     </item>
-    </layout>
+    <layout class="QHBoxLayout" name="hlPreview"/>
    </item>
   </layout>
  </widget>
diff --git a/tests/import_export/ROOT/data/advanced_zlib.root b/tests/import_export/ROOT/data/advanced_zlib.root
index 197c563658d1a003f7bfa462ef052c1375b98277..46f8dd01c4abcdda9d8e9699094af71d2f372c52
GIT binary patch
literal 11567
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
CsCi-l

literal 6084
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
Ds~<fZ

diff --git a/tests/import_export/ROOT/data/samplefiles.C b/tests/import_export/ROOT/data/samplefiles.C
new file mode 100644
--- /dev/null
+++ b/tests/import_export/ROOT/data/samplefiles.C
@@ -0,0 +1,113 @@
+/***************************************************************************
+File                 : samplefiles.C
+Project              : LabPlot
+Description          : ROOT script to create test files for ROOT importer
+-------------------------------------------------------------------------
+Copyright            : (C) 2018 by Christoph Roick (chrisito@gmx.de)
+***************************************************************************/
+
+/***************************************************************************
+*                                                                         *
+*  This program is free software; you can redistribute it and/or modify   *
+*  it under the terms of the GNU General Public License as published by   *
+*  the Free Software Foundation; either version 2 of the License, or      *
+*  (at your option) any later version.                                    *
+*                                                                         *
+*  This program is distributed in the hope that it will be useful,        *
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
+*  GNU General Public License for more details.                           *
+*                                                                         *
+*   You should have received a copy of the GNU General Public License     *
+*   along with this program; if not, write to the Free Software           *
+*   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
+*   Boston, MA  02110-1301  USA                                           *
+*                                                                         *
+***************************************************************************/
+
+// ROOT test files are regenerated by calling 'root samplefiles.C'.
+// Note that creation date and random numbers will be different in the new files.
+
+void samplefiles()
+{
+	TFile fBasic("basic_lz4.root", "RECREATE");
+	fBasic.SetCompressionAlgorithm(ROOT::kLZ4);
+
+	TH1D doubleHist("doubleHist", "", 100, -5., 5.);
+	doubleHist.Sumw2();
+	doubleHist.FillRandom("gaus", 10000);
+	doubleHist.Write();
+
+	TH1F floatHist("floatHist", "", 100, -5., 5.);
+	floatHist.Sumw2();
+	floatHist.FillRandom("gaus", 10000);
+	floatHist.Write();
+
+	TH1I intHist("intHist", "", 100, -5., 5.);
+	intHist.Sumw2();
+	intHist.FillRandom("gaus", 10000);
+	intHist.Write();
+
+	TH1S shortHist("shortHist", "", 100, -5., 5.);
+	shortHist.Sumw2();
+	shortHist.FillRandom("gaus", 10000);
+	shortHist.Write();
+
+	TH1C charHist("charHist", "", 100, -5., 5.);
+	charHist.Sumw2();
+	charHist.FillRandom("gaus", 1000);
+	charHist.Write();
+
+	fBasic.Close();
+
+	TFile fAdvanced("advanced_zlib.root", "RECREATE");
+	fAdvanced.SetCompressionAlgorithm(ROOT::kZLIB);
+
+	vector<double> borders;
+	for (size_t i = 0; i < 101; ++i)
+		borders.push_back(0.09 * i - 5. + 1.e-4 * i * i);
+
+	TH1D variableBinHist("variableBinHist", "", 100, borders.data());
+	variableBinHist.Sumw2();
+	variableBinHist.FillRandom("gaus", 10000);
+	variableBinHist.Write();
+	variableBinHist.FillRandom("gaus", 1000000);
+	variableBinHist.Write();
+
+	TTree tree("tree", "TTree title");
+	double d;
+	int i;
+	struct {
+		int a[2];
+		Double_t d;
+		float f;
+	} s;
+	tree.Branch("doubleTest", &d, "doubleTest/D");
+	tree.Branch("intTest", &i, "intTest/I");
+	tree.Branch("structTest", &s, "array[2]/I:double/D:float/F");
+
+	for (size_t j = 0; j < 10; ++j) {
+		d = j;
+		i = j;
+		s.f = 9 - j;
+		s.a[0] = j; s.a[1] = 2 * j;
+		s.d = s.f * s.f;
+		tree.Fill();
+	}
+	tree.Write();
+
+	TNtuple tuple("tuple", "TNtuple title", "x:y:z");
+	tuple.Fill(1., 2., 3.);
+	tuple.Write();
+	tuple.Fill(3., 4., 5.);
+	tuple.Write();
+
+	fAdvanced.Close();
+
+	ifstream infile("basic_lz4.root");
+	ofstream outfile("broken_basic.root");
+
+	char buffer[3000];
+	infile.read(buffer, 3000);
+	outfile.write(buffer, 3000);
+}
diff --git a/tests/import_export/ROOT/data/samplehists.C b/tests/import_export/ROOT/data/samplehists.C
deleted file mode 100644
--- a/tests/import_export/ROOT/data/samplehists.C
+++ /dev/null
@@ -1,85 +0,0 @@
-/***************************************************************************
-File                 : samplehists.C
-Project              : LabPlot
-Description          : ROOT script to create test files for ROOT importer
--------------------------------------------------------------------------
-Copyright            : (C) 2018 by Christoph Roick (chrisito@gmx.de)
-***************************************************************************/
-
-/***************************************************************************
-*                                                                         *
-*  This program is free software; you can redistribute it and/or modify   *
-*  it under the terms of the GNU General Public License as published by   *
-*  the Free Software Foundation; either version 2 of the License, or      *
-*  (at your option) any later version.                                    *
-*                                                                         *
-*  This program is distributed in the hope that it will be useful,        *
-*  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
-*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
-*  GNU General Public License for more details.                           *
-*                                                                         *
-*   You should have received a copy of the GNU General Public License     *
-*   along with this program; if not, write to the Free Software           *
-*   Foundation, Inc., 51 Franklin Street, Fifth Floor,                    *
-*   Boston, MA  02110-1301  USA                                           *
-*                                                                         *
-***************************************************************************/
-
-// ROOT test files are regenerated by calling 'root samplehists.C'.
-// Note that creation date and random numbers will be different in the new files.
-
-void samplehists()
-{
-    TFile fBasic("basic_lz4.root", "RECREATE");
-    fBasic.SetCompressionAlgorithm(ROOT::kLZ4);
-
-    TH1D doubleHist("doubleHist", "", 100, -5., 5.);
-    doubleHist.Sumw2();
-    doubleHist.FillRandom("gaus", 10000);
-    doubleHist.Write();
-
-    TH1F floatHist("floatHist", "", 100, -5., 5.);
-    floatHist.Sumw2();
-    floatHist.FillRandom("gaus", 10000);
-    floatHist.Write();
-
-    TH1I intHist("intHist", "", 100, -5., 5.);
-    intHist.Sumw2();
-    intHist.FillRandom("gaus", 10000);
-    intHist.Write();
-
-    TH1S shortHist("shortHist", "", 100, -5., 5.);
-    shortHist.Sumw2();
-    shortHist.FillRandom("gaus", 10000);
-    shortHist.Write();
-
-    TH1C charHist("charHist", "", 100, -5., 5.);
-    charHist.Sumw2();
-    charHist.FillRandom("gaus", 1000);
-    charHist.Write();
-
-    fBasic.Close();
-
-    TFile fAdvanced("advanced_zlib.root", "RECREATE");
-    fAdvanced.SetCompressionAlgorithm(ROOT::kZLIB);
-
-    vector<double> borders;
-    for (size_t i = 0; i < 101; ++i)
-        borders.push_back(0.09 * i - 5. + 1.e-4 * i * i);
-
-    TH1D variableBinHist("variableBinHist", "", 100, borders.data());
-    variableBinHist.Sumw2();
-    variableBinHist.FillRandom("gaus", 10000);
-    variableBinHist.Write();
-    variableBinHist.FillRandom("gaus", 1000000);
-    variableBinHist.Write();
-
-    fAdvanced.Close();
-
-    ifstream infile("basic_lz4.root");
-    ofstream outfile("broken_basic.root");
-
-    char buffer[3000];
-    infile.read(buffer, 3000);
-    outfile.write(buffer, 3000);
-}