From 22ac8cf45151f79edacd4418f3f823b5541c36e3 Mon Sep 17 00:00:00 2001
From: oliverhaag <OliverHaag@users.noreply.github.com>
Date: Mon, 23 Aug 2010 19:20:41 +0000
Subject: [PATCH] Updated export functionality and bulk command enum

---
 openhantek/ChangeLog          |   6 ++++++
 openhantek/mainpage.dox       |   6 +++---
 openhantek/src/dsowidget.cpp  |   2 +-
 openhantek/src/exporter.cpp   | 264 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------
 openhantek/src/hantek/types.h |  63 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 openhantek/src/openhantek.cpp |  88 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------
 openhantek/src/settings.cpp   |   4 ++--
 7 files changed, 294 insertions(+), 139 deletions(-)

diff --git a/openhantek/ChangeLog b/openhantek/ChangeLog
index cc17bc6..64fedd2 100644
--- a/openhantek/ChangeLog
+++ b/openhantek/ChangeLog
@@ -45,3 +45,9 @@
 * Moved constants.h to dso.h and added functions that return strings for enums
 * Sample buffer size above scope shows real sample count got from oscilloscope
 * Documentation updated
+
+2010-08-23  Oliver Haag  <oliver.haag@gmail.com>
+* Saving color settings for printing too
+* Added zoomed scope and markers to exports
+* Darker default colors for channels in print mode
+* Added enum values for DSO-5200 bulk commands
diff --git a/openhantek/mainpage.dox b/openhantek/mainpage.dox
index f250e6a..4dc4f30 100644
--- a/openhantek/mainpage.dox
+++ b/openhantek/mainpage.dox
@@ -15,7 +15,7 @@ You need the development packages for the following libraries to build OpenHante
 	<li><a href="http://www.opengl.org/">OpenGL</a></li>
 </ul>
 
-\subsection ssec_dependencies Building
+\subsection ssec_building Building
 After installing these you can build it by running:
 <pre>
 	$ qmake
@@ -23,7 +23,7 @@ After installing these you can build it by running:
 	$ make install
 </pre>
 
-\subsection ssec_dependencies Build options
+\subsection ssec_options Build options
 You can set environment variables to set various build options (Done best by prepending env VARIABLE=value to the qmake command). The known environment variables are:
 <ul>
 	<li>
@@ -44,7 +44,7 @@ You need the tool dsoextractfw from the sourceforge page too extract the firmwar
 <pre>
 	$ make
 </pre>
-After building it you have to place the DSO*1.SYS file into the same directory and run the built binary:
+After building it, you have to place the DSO*1.SYS file into the same directory and run the built binary:
 <pre>
 	$ ./dsoextractfw
 </pre>
diff --git a/openhantek/src/dsowidget.cpp b/openhantek/src/dsowidget.cpp
index b894af7..1a4583c 100644
--- a/openhantek/src/dsowidget.cpp
+++ b/openhantek/src/dsowidget.cpp
@@ -278,7 +278,7 @@ void DsoWidget::setMeasurementVisible(unsigned int channel, bool visible) {
 /// \brief Update the label about the marker measurements
 void DsoWidget::updateMarkerDetails() {
 	double divs = fabs(this->settings->scope.horizontal.marker[1] - this->settings->scope.horizontal.marker[0]);
-	double time = divs  * this->settings->scope.horizontal.timebase;
+	double time = divs * this->settings->scope.horizontal.timebase;
 	
 	if(this->settings->view.zoom) {
 		this->markerInfoLabel->setText(tr("Zoom x%L1").arg(DIVS_TIME / divs, -1, 'g', 3));
diff --git a/openhantek/src/exporter.cpp b/openhantek/src/exporter.cpp
index 5a5aa9c..40f67f1 100644
--- a/openhantek/src/exporter.cpp
+++ b/openhantek/src/exporter.cpp
@@ -22,6 +22,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 
+#include <cmath>
+
 #include <QImage>
 #include <QMutex>
 #include <QPainter>
@@ -142,7 +144,7 @@ bool Exporter::doExport() {
 	// Draw the measurement table
 	stretchBase = (double) (paintDevice->width() - lineHeight * 6) / 10;
 	int channelCount = 0;
-	for(int channel = 0; channel < this->settings->scope.voltage.count(); channel++) {
+	for(int channel = this->settings->scope.voltage.count() - 1; channel >= 0; channel--) {
 		if(this->settings->scope.voltage[channel].used || this->settings->scope.spectrum[channel].used) {
 			channelCount++;
 			double top = (double) paintDevice->height() - channelCount * lineHeight;
@@ -170,130 +172,188 @@ bool Exporter::doExport() {
 		}
 	}
 	
+	// Draw the marker table
+	double scopeHeight;
+	stretchBase = (double) (paintDevice->width() - lineHeight * 10) / 4;
+	painter.setPen(colorValues->text);
+	
+	// Calculate variables needed for zoomed scope
+	double divs = fabs(this->settings->scope.horizontal.marker[1] - this->settings->scope.horizontal.marker[0]);
+	double time = divs * this->settings->scope.horizontal.timebase;
+	double zoomFactor = DIVS_TIME / divs;
+	double zoomOffset = (this->settings->scope.horizontal.marker[0] + this->settings->scope.horizontal.marker[1]) / 2;
+	
+	if(this->settings->view.zoom) {
+		scopeHeight = (double) (paintDevice->height() - (channelCount + 5) * lineHeight) / 2;
+		double top = 2.5 * lineHeight + scopeHeight;
+		
+		painter.drawText(QRectF(0, top, stretchBase, lineHeight), tr("Zoom x%L1").arg(DIVS_TIME / divs, -1, 'g', 3));
+		
+		painter.drawText(QRectF(lineHeight * 10, top, stretchBase, lineHeight), Helper::valueToString(time, Helper::UNIT_SECONDS, 4), QTextOption(Qt::AlignRight));
+		painter.drawText(QRectF(lineHeight * 10 + stretchBase, top, stretchBase, lineHeight), Helper::valueToString(1.0 / time, Helper::UNIT_HERTZ, 4), QTextOption(Qt::AlignRight));
+		
+		painter.drawText(QRectF(lineHeight * 10 + stretchBase * 2, top, stretchBase, lineHeight), Helper::valueToString(time / DIVS_TIME, Helper::UNIT_SECONDS, 3) + tr("/div"), QTextOption(Qt::AlignRight));
+		painter.drawText(QRectF(lineHeight * 10 + stretchBase * 3, top, stretchBase, lineHeight), Helper::valueToString(divs  * this->settings->scope.horizontal.frequencybase / DIVS_TIME, Helper::UNIT_HERTZ, 3) + tr("/div"), QTextOption(Qt::AlignRight));
+	}
+	else {
+		scopeHeight = (double) paintDevice->height() - (channelCount + 4) * lineHeight;
+		double top = 2.5 * lineHeight + scopeHeight;
+		
+		painter.drawText(QRectF(0, top, stretchBase, lineHeight), tr("Marker 1/2"));
+		
+		painter.drawText(QRectF(lineHeight * 10, top, stretchBase * 2, lineHeight), Helper::valueToString(time, Helper::UNIT_SECONDS, 4), QTextOption(Qt::AlignRight));
+		painter.drawText(QRectF(lineHeight * 10 + stretchBase * 2, top, stretchBase * 2, lineHeight), Helper::valueToString(1.0 / time, Helper::UNIT_HERTZ, 4), QTextOption(Qt::AlignRight));
+	}
+	
 	// Set DIVS_TIME x DIVS_VOLTAGE matrix for oscillograph
-	double screenHeight = (double) paintDevice->height() - (channelCount + 3) * lineHeight;
-	painter.setMatrix(QMatrix((paintDevice->width() - 1) / DIVS_TIME, 0, 0, -(screenHeight - 1) / DIVS_VOLTAGE, (double) (paintDevice->width() - 1) / 2, (screenHeight - 1) / 2 + lineHeight * 2), false);
+	painter.setMatrix(QMatrix((paintDevice->width() - 1) / DIVS_TIME, 0, 0, -(scopeHeight - 1) / DIVS_VOLTAGE, (double) (paintDevice->width() - 1) / 2, (scopeHeight - 1) / 2 + lineHeight * 1.5), false);
 	
 	// Draw the graphs
 	painter.setRenderHint(QPainter::Antialiasing);
 	painter.setBrush(Qt::NoBrush);
 	
-	switch(this->settings->scope.horizontal.format) {
-		case Dso::GRAPHFORMAT_TY:
-			// Add graphs for channels
-			for(int channel = 0 ; channel < this->settings->scope.voltage.count(); channel++) {
-				if(this->settings->scope.voltage[channel].used) {
-					painter.setPen(colorValues->voltage[channel]);
-					
-					// What's the horizontal distance between sampling points?
-					double horizontalFactor = this->dataAnalyzer->data(channel)->samples.voltage.interval / this->settings->scope.horizontal.timebase;
-					// How many samples are visible?
-					unsigned int lastPosition = DIVS_TIME / horizontalFactor;
-					if(lastPosition >= this->dataAnalyzer->data(channel)->samples.voltage.count)
-						lastPosition = this->dataAnalyzer->data(channel)->samples.voltage.count - 1;
-					
-					// Draw graph
-					QPointF *graph = new QPointF[lastPosition + 1];
-					for(unsigned int position = 0; position <= lastPosition; position++)
-						graph[position] = QPointF(position * horizontalFactor - DIVS_TIME / 2, this->dataAnalyzer->data(channel)->samples.voltage.sample[position] / this->settings->scope.voltage[channel].gain + this->settings->scope.voltage[channel].offset);
-					painter.drawPolyline(graph, lastPosition + 1);
+	for(int zoomed = 0; zoomed < (this->settings->view.zoom ? 2 : 1); zoomed++) {
+		switch(this->settings->scope.horizontal.format) {
+			case Dso::GRAPHFORMAT_TY:
+				// Add graphs for channels
+				for(int channel = 0 ; channel < this->settings->scope.voltage.count(); channel++) {
+					if(this->settings->scope.voltage[channel].used) {
+						painter.setPen(colorValues->voltage[channel]);
+						
+						// What's the horizontal distance between sampling points?
+						double horizontalFactor = this->dataAnalyzer->data(channel)->samples.voltage.interval / this->settings->scope.horizontal.timebase;
+						// How many samples are visible?
+						double centerPosition, centerOffset;
+						if(zoomed) {
+							centerPosition = (zoomOffset + DIVS_TIME / 2) / horizontalFactor;
+							centerOffset = DIVS_TIME / horizontalFactor / zoomFactor / 2;
+						}
+						else {
+							centerPosition = DIVS_TIME / 2 / horizontalFactor;
+							centerOffset = DIVS_TIME / horizontalFactor / 2;
+						}
+						unsigned int firstPosition = qMax((int) (centerPosition - centerOffset), 0);
+						unsigned int lastPosition = qMin((int) (centerPosition + centerOffset), (int) this->dataAnalyzer->data(channel)->samples.voltage.count - 1);
+						
+						// Draw graph
+						QPointF *graph = new QPointF[lastPosition - firstPosition + 1];
+						for(unsigned int position = firstPosition; position <= lastPosition; position++)
+							graph[position - firstPosition] = QPointF(position * horizontalFactor - DIVS_TIME / 2, this->dataAnalyzer->data(channel)->samples.voltage.sample[position] / this->settings->scope.voltage[channel].gain + this->settings->scope.voltage[channel].offset);
+						painter.drawPolyline(graph, lastPosition - firstPosition + 1);
+					}
 				}
-			}
-		
-			// Add spectrum graphs
-			for (int channel = 0; channel < this->settings->scope.spectrum.count(); channel++) {
-				if(this->settings->scope.spectrum[channel].used) {
-					painter.setPen(colorValues->spectrum[channel]);
-					
-					// What's the horizontal distance between sampling points?
-					double horizontalFactor = this->dataAnalyzer->data(channel)->samples.spectrum.interval / this->settings->scope.horizontal.frequencybase;
-					// How many samples are visible?
-					unsigned int lastPosition = DIVS_TIME / horizontalFactor;
-					if(lastPosition >= this->dataAnalyzer->data(channel)->samples.spectrum.count)
-						lastPosition = this->dataAnalyzer->data(channel)->samples.spectrum.count - 1;
-					
-					// Draw graph
-					QPointF *graph = new QPointF[lastPosition + 1];
-					for(unsigned int position = 0; position <= lastPosition; position++)
-						graph[position] = QPointF(position * horizontalFactor - DIVS_TIME / 2, this->dataAnalyzer->data(channel)->samples.spectrum.sample[position] / this->settings->scope.spectrum[channel].magnitude + this->settings->scope.spectrum[channel].offset);
-					painter.drawPolyline(graph, lastPosition + 1);
+			
+				// Add spectrum graphs
+				for (int channel = 0; channel < this->settings->scope.spectrum.count(); channel++) {
+					if(this->settings->scope.spectrum[channel].used) {
+						painter.setPen(colorValues->spectrum[channel]);
+						
+						// What's the horizontal distance between sampling points?
+						double horizontalFactor = this->dataAnalyzer->data(channel)->samples.spectrum.interval / this->settings->scope.horizontal.frequencybase;
+						// How many samples are visible?
+						double centerPosition, centerOffset;
+						if(zoomed) {
+							centerPosition = (zoomOffset + DIVS_TIME / 2) / horizontalFactor;
+							centerOffset = DIVS_TIME / horizontalFactor / zoomFactor / 2;
+						}
+						else {
+							centerPosition = DIVS_TIME / 2 / horizontalFactor;
+							centerOffset = DIVS_TIME / horizontalFactor / 2;
+						}
+						unsigned int firstPosition = qMax((int) (centerPosition - centerOffset), 0);
+						unsigned int lastPosition = qMin((int) (centerPosition + centerOffset), (int) this->dataAnalyzer->data(channel)->samples.spectrum.count - 1);
+						
+						// Draw graph
+						QPointF *graph = new QPointF[lastPosition - firstPosition + 1];
+						for(unsigned int position = firstPosition; position <= lastPosition; position++)
+							graph[position - firstPosition] = QPointF(position * horizontalFactor - DIVS_TIME / 2, this->dataAnalyzer->data(channel)->samples.spectrum.sample[position] / this->settings->scope.spectrum[channel].magnitude + this->settings->scope.spectrum[channel].offset);
+						painter.drawPolyline(graph, lastPosition - firstPosition + 1);
+					}
 				}
-			}
-			break;
+				break;
+				
+			case Dso::GRAPHFORMAT_XY:
+				break;
 			
-		case Dso::GRAPHFORMAT_XY:
-			break;
+			default:
+				break;
+		}
 		
-		default:
-			break;
+		// Set DIVS_TIME / zoomFactor x DIVS_VOLTAGE matrix for zoomed oscillograph
+		painter.setMatrix(QMatrix((paintDevice->width() - 1) / DIVS_TIME * zoomFactor, 0, 0, -(scopeHeight - 1) / DIVS_VOLTAGE, (double) (paintDevice->width() - 1) / 2 - zoomOffset * zoomFactor * (paintDevice->width() - 1) / DIVS_TIME, (scopeHeight - 1) * 1.5 + lineHeight * 4), false);
 	}
 	
 	this->dataAnalyzer->mutex()->unlock();
 	
-	// Draw grid
+	// Draw grids
 	painter.setRenderHint(QPainter::Antialiasing, false);
-	// Grid lines
-	painter.setPen(colorValues->grid);
-	
-	if(this->format < EXPORT_FORMAT_IMAGE) {
-		// Draw vertical lines
-		for(int div = 1; div < DIVS_TIME / 2; div++) {
-			for(int dot = 1; dot < DIVS_VOLTAGE / 2 * 5; dot++) {
-				painter.drawLine(QPointF((double) -div - 0.02, (double) -dot / 5), QPointF((double) -div + 0.02, (double) -dot / 5));
-				painter.drawLine(QPointF((double) -div - 0.02, (double) dot / 5), QPointF((double) -div + 0.02, (double) dot / 5));
-				painter.drawLine(QPointF((double) div - 0.02, (double) -dot / 5), QPointF((double) div + 0.02, (double) -dot / 5));
-				painter.drawLine(QPointF((double) div - 0.02, (double) dot / 5), QPointF((double) div + 0.02, (double) dot / 5));
+	for(int zoomed = 0; zoomed < (this->settings->view.zoom ? 2 : 1); zoomed++) {
+		// Set DIVS_TIME x DIVS_VOLTAGE matrix for oscillograph
+		painter.setMatrix(QMatrix((paintDevice->width() - 1) / DIVS_TIME, 0, 0, -(scopeHeight - 1) / DIVS_VOLTAGE, (double) (paintDevice->width() - 1) / 2, (scopeHeight - 1) * (zoomed + 0.5) + lineHeight * 1.5 + lineHeight * 2.5 * zoomed), false);
+		
+		// Grid lines
+		painter.setPen(colorValues->grid);
+		
+		if(this->format < EXPORT_FORMAT_IMAGE) {
+			// Draw vertical lines
+			for(int div = 1; div < DIVS_TIME / 2; div++) {
+				for(int dot = 1; dot < DIVS_VOLTAGE / 2 * 5; dot++) {
+					painter.drawLine(QPointF((double) -div - 0.02, (double) -dot / 5), QPointF((double) -div + 0.02, (double) -dot / 5));
+					painter.drawLine(QPointF((double) -div - 0.02, (double) dot / 5), QPointF((double) -div + 0.02, (double) dot / 5));
+					painter.drawLine(QPointF((double) div - 0.02, (double) -dot / 5), QPointF((double) div + 0.02, (double) -dot / 5));
+					painter.drawLine(QPointF((double) div - 0.02, (double) dot / 5), QPointF((double) div + 0.02, (double) dot / 5));
+				}
 			}
-		}
-		// Draw horizontal lines
-		for(int div = 1; div < DIVS_VOLTAGE / 2; div++) {
-			for(int dot = 1; dot < DIVS_TIME / 2 * 5; dot++) {
-				painter.drawLine(QPointF((double) -dot / 5, (double) -div - 0.02), QPointF((double) -dot / 5, (double) -div + 0.02));
-				painter.drawLine(QPointF((double) dot / 5, (double) -div - 0.02), QPointF((double) dot / 5, (double) -div + 0.02));
-				painter.drawLine(QPointF((double) -dot / 5, (double) div - 0.02), QPointF((double) -dot / 5, (double) div + 0.02));
-				painter.drawLine(QPointF((double) dot / 5, (double) div - 0.02), QPointF((double) dot / 5, (double) div + 0.02));
+			// Draw horizontal lines
+			for(int div = 1; div < DIVS_VOLTAGE / 2; div++) {
+				for(int dot = 1; dot < DIVS_TIME / 2 * 5; dot++) {
+					painter.drawLine(QPointF((double) -dot / 5, (double) -div - 0.02), QPointF((double) -dot / 5, (double) -div + 0.02));
+					painter.drawLine(QPointF((double) dot / 5, (double) -div - 0.02), QPointF((double) dot / 5, (double) -div + 0.02));
+					painter.drawLine(QPointF((double) -dot / 5, (double) div - 0.02), QPointF((double) -dot / 5, (double) div + 0.02));
+					painter.drawLine(QPointF((double) dot / 5, (double) div - 0.02), QPointF((double) dot / 5, (double) div + 0.02));
+				}
 			}
 		}
-	}
-	else {
-		// Draw vertical lines
-		for(int div = 1; div < DIVS_TIME / 2; div++) {
-			for(int dot = 1; dot < DIVS_VOLTAGE / 2 * 5; dot++) {
-				painter.drawPoint(QPointF(-div, (double) -dot / 5));
-				painter.drawPoint(QPointF(-div, (double) dot / 5));
-				painter.drawPoint(QPointF(div, (double) -dot / 5));
-				painter.drawPoint(QPointF(div, (double) dot / 5));
+		else {
+			// Draw vertical lines
+			for(int div = 1; div < DIVS_TIME / 2; div++) {
+				for(int dot = 1; dot < DIVS_VOLTAGE / 2 * 5; dot++) {
+					painter.drawPoint(QPointF(-div, (double) -dot / 5));
+					painter.drawPoint(QPointF(-div, (double) dot / 5));
+					painter.drawPoint(QPointF(div, (double) -dot / 5));
+					painter.drawPoint(QPointF(div, (double) dot / 5));
+				}
 			}
-		}
-		// Draw horizontal lines
-		for(int div = 1; div < DIVS_VOLTAGE / 2; div++) {
-			for(int dot = 1; dot < DIVS_TIME / 2 * 5; dot++) {
-				if(dot % 5 == 0)
-					continue;                       // Already done by vertical lines
-				painter.drawPoint(QPointF((double) -dot / 5, -div));
-				painter.drawPoint(QPointF((double) dot / 5, -div));
-				painter.drawPoint(QPointF((double) -dot / 5, div));
-				painter.drawPoint(QPointF((double) dot / 5, div));
+			// Draw horizontal lines
+			for(int div = 1; div < DIVS_VOLTAGE / 2; div++) {
+				for(int dot = 1; dot < DIVS_TIME / 2 * 5; dot++) {
+					if(dot % 5 == 0)
+						continue;                       // Already done by vertical lines
+					painter.drawPoint(QPointF((double) -dot / 5, -div));
+					painter.drawPoint(QPointF((double) dot / 5, -div));
+					painter.drawPoint(QPointF((double) -dot / 5, div));
+					painter.drawPoint(QPointF((double) dot / 5, div));
+				}
 			}
 		}
-	}
+			
+		// Axes
+		painter.setPen(colorValues->axes);
+		painter.drawLine(QPointF(-DIVS_TIME / 2, 0), QPointF(DIVS_TIME / 2, 0));
+		painter.drawLine(QPointF(0, -DIVS_VOLTAGE / 2), QPointF(0, DIVS_VOLTAGE / 2));
+		for(double div = 0.2; div <= DIVS_TIME / 2; div += 0.2) {
+			painter.drawLine(QPointF(div, -0.05), QPointF(div, 0.05));
+			painter.drawLine(QPointF(-div, -0.05), QPointF(-div, 0.05));
+		}
+		for(double div = 0.2; div <= DIVS_VOLTAGE / 2; div += 0.2) {
+			painter.drawLine(QPointF(-0.05, div), QPointF(0.05, div));
+			painter.drawLine(QPointF(-0.05, -div), QPointF(0.05, -div));
+		}
 		
-	// Axes
-	painter.setPen(colorValues->axes);
-	painter.drawLine(QPointF(-DIVS_TIME / 2, 0), QPointF(DIVS_TIME / 2, 0));
-	painter.drawLine(QPointF(0, -DIVS_VOLTAGE / 2), QPointF(0, DIVS_VOLTAGE / 2));
-	for(double div = 0.2; div <= DIVS_TIME / 2; div += 0.2) {
-		painter.drawLine(QPointF(div, -0.05), QPointF(div, 0.05));
-		painter.drawLine(QPointF(-div, -0.05), QPointF(-div, 0.05));
+		// Borders
+		painter.setPen(colorValues->border);
+		painter.drawRect(QRectF(-DIVS_TIME / 2, -DIVS_VOLTAGE / 2, DIVS_TIME, DIVS_VOLTAGE));
 	}
-	for(double div = 0.2; div <= DIVS_VOLTAGE / 2; div += 0.2) {
-		painter.drawLine(QPointF(-0.05, div), QPointF(0.05, div));
-		painter.drawLine(QPointF(-0.05, -div), QPointF(0.05, -div));
-	}
-	
-	// Borders
-	painter.setPen(colorValues->border);
-	painter.drawRect(QRectF(-DIVS_TIME / 2, -DIVS_VOLTAGE / 2, DIVS_TIME, DIVS_VOLTAGE));
 	
 	painter.end();
 	
diff --git a/openhantek/src/hantek/types.h b/openhantek/src/hantek/types.h
index 302c84d..73203eb 100644
--- a/openhantek/src/hantek/types.h
+++ b/openhantek/src/hantek/types.h
@@ -208,6 +208,69 @@ namespace Hantek {
 		/// </table>
 		COMMAND_GETLOGICALDATA,
 		
+		/// This command isn't used for the DSO-2090 and DSO-5200:
+		/// <table>
+		///   <tr>
+		///     <td>0x0a</td>
+		///     <td>...</td>
+		///   </tr>
+		/// </table>
+		COMMAND_UNKNOWN_0A,
+		
+		/// This command isn't used for the DSO-2090 and DSO-5200:
+		/// <table>
+		///   <tr>
+		///     <td>0x0b</td>
+		///     <td>...</td>
+		///   </tr>
+		/// </table>
+		COMMAND_UNKNOWN_0B,
+		
+		/// This command seems to set the sampling rate for the DSO-5200:
+		/// <table>
+		///   <tr>
+		///     <td>0x0c</td>
+		///     <td>0x00</td>
+		///     <td>Samplerate[0] (?)</td>
+		///     <td>Samplerate[1] (?)</td>
+		///     <td>Unknown</td>
+		///     <td>0x00</td>
+		///   </tr>
+		/// </table>
+		COMMAND_DSO5200_0C,
+		
+		/// This command seems to set trigger settings for the DSO-5200:
+		/// <table>
+		///   <tr>
+		///     <td>0x0d</td>
+		///     <td>0x00</td>
+		///     <td>Unknown</td>
+		///     <td>Unknown</td>
+		///     <td>TriggerPoint (?)</td>
+		///     <td>0xff</td>
+		///     <td>TriggerPoint (?)</td>
+		///     <td>0xff</td>
+		///     <td>TriggerPoint (?)</td>
+		///     <td>0xff</td>
+		///   </tr>
+		/// </table>
+		COMMAND_DSO5200_0D,
+		
+		/// This command seems to set some additional settings for the DSO-5200:
+		/// <table>
+		///   <tr>
+		///     <td>0x0e</td>
+		///     <td>0x00</td>
+		///     <td>Unknown</td>
+		///     <td>0x00</td>
+		///     <td>Unknown</td>
+		///     <td>0x00</td>
+		///     <td>0x00</td>
+		///     <td>0x00</td>
+		///   </tr>
+		/// </table>
+		COMMAND_DSO5200_0E,
+		
 		COMMAND_COUNT ///< Total number of commands
 	};
 	
diff --git a/openhantek/src/openhantek.cpp b/openhantek/src/openhantek.cpp
index af42158..b783b6f 100644
--- a/openhantek/src/openhantek.cpp
+++ b/openhantek/src/openhantek.cpp
@@ -405,27 +405,40 @@ void OpenHantekMainWindow::readSettings(const QString &fileName) {
 	settingsLoader->beginGroup("view");
 	// Colors
 	settingsLoader->beginGroup("color");
-	if(settingsLoader->contains("axes"))
-		this->settings->view.color.screen.axes = settingsLoader->value("axes").value<QColor>();
-	if(settingsLoader->contains("background"))
-		this->settings->view.color.screen.background = settingsLoader->value("background").value<QColor>();
-	if(settingsLoader->contains("border"))
-		this->settings->view.color.screen.border = settingsLoader->value("border").value<QColor>();
-	if(settingsLoader->contains("grid"))
-		this->settings->view.color.screen.grid = settingsLoader->value("grid").value<QColor>();
-	if(settingsLoader->contains("markers"))
-		this->settings->view.color.screen.markers = settingsLoader->value("markers").value<QColor>();
-	for(int channel = 0; channel < this->settings->scope.spectrum.count(); channel++) {
-		QString key = QString("spectrum%1").arg(channel);
-		if(settingsLoader->contains(key))
-			this->settings->view.color.screen.spectrum[channel] = settingsLoader->value(key).value<QColor>();
-	}
-	if(settingsLoader->contains("text"))
-		this->settings->view.color.screen.text = settingsLoader->value("text").value<QColor>();
-	for(int channel = 0; channel < this->settings->scope.voltage.count(); channel++) {
-		QString key = QString("voltage%1").arg(channel);
-		if(settingsLoader->contains(key))
-			this->settings->view.color.screen.voltage[channel] = settingsLoader->value(key).value<QColor>();
+	DsoSettingsColorValues *colors;
+	for(int mode = 0; mode < 2; mode++) {
+		if(mode == 0) {
+			colors = &this->settings->view.color.screen;
+			settingsLoader->beginGroup("screen");
+		}
+		else {
+			colors = &this->settings->view.color.print;
+			settingsLoader->beginGroup("print");
+		}
+		
+		if(settingsLoader->contains("axes"))
+			colors->axes = settingsLoader->value("axes").value<QColor>();
+		if(settingsLoader->contains("background"))
+			colors->background = settingsLoader->value("background").value<QColor>();
+		if(settingsLoader->contains("border"))
+			colors->border = settingsLoader->value("border").value<QColor>();
+		if(settingsLoader->contains("grid"))
+			colors->grid = settingsLoader->value("grid").value<QColor>();
+		if(settingsLoader->contains("markers"))
+			colors->markers = settingsLoader->value("markers").value<QColor>();
+		for(int channel = 0; channel < this->settings->scope.spectrum.count(); channel++) {
+			QString key = QString("spectrum%1").arg(channel);
+			if(settingsLoader->contains(key))
+				colors->spectrum[channel] = settingsLoader->value(key).value<QColor>();
+		}
+		if(settingsLoader->contains("text"))
+			colors->text = settingsLoader->value("text").value<QColor>();
+		for(int channel = 0; channel < this->settings->scope.voltage.count(); channel++) {
+			QString key = QString("voltage%1").arg(channel);
+			if(settingsLoader->contains(key))
+				colors->voltage[channel] = settingsLoader->value(key).value<QColor>();
+		}
+		settingsLoader->endGroup();
 	}
 	settingsLoader->endGroup();
 	// Other view settings
@@ -507,16 +520,29 @@ void OpenHantekMainWindow::writeSettings(const QString &fileName) {
 	// Colors
 	if(complete) {
 		settingsSaver->beginGroup("color");
-		settingsSaver->setValue("axes", this->settings->view.color.screen.axes);
-		settingsSaver->setValue("background", this->settings->view.color.screen.background);
-		settingsSaver->setValue("border", this->settings->view.color.screen.border);
-		settingsSaver->setValue("grid", this->settings->view.color.screen.grid);
-		settingsSaver->setValue("markers", this->settings->view.color.screen.markers);
-		for(int channel = 0; channel < this->settings->scope.spectrum.count(); channel++)
-			settingsSaver->setValue(QString("spectrum%1").arg(channel), this->settings->view.color.screen.spectrum[channel]);
-		settingsSaver->setValue("text", this->settings->view.color.screen.text);
-		for(int channel = 0; channel < this->settings->scope.voltage.count(); channel++)
-			settingsSaver->setValue(QString("voltage%1").arg(channel), this->settings->view.color.screen.voltage[channel]);
+		DsoSettingsColorValues *colors;
+		for(int mode = 0; mode < 2; mode++) {
+			if(mode == 0) {
+				colors = &this->settings->view.color.screen;
+				settingsSaver->beginGroup("screen");
+			}
+			else {
+				colors = &this->settings->view.color.print;
+				settingsSaver->beginGroup("print");
+			}
+			
+			settingsSaver->setValue("axes", colors->axes);
+			settingsSaver->setValue("background", colors->background);
+			settingsSaver->setValue("border", colors->border);
+			settingsSaver->setValue("grid", colors->grid);
+			settingsSaver->setValue("markers", colors->markers);
+			for(int channel = 0; channel < this->settings->scope.spectrum.count(); channel++)
+				settingsSaver->setValue(QString("spectrum%1").arg(channel), colors->spectrum[channel]);
+			settingsSaver->setValue("text", colors->text);
+			for(int channel = 0; channel < this->settings->scope.voltage.count(); channel++)
+				settingsSaver->setValue(QString("voltage%1").arg(channel), colors->voltage[channel]);
+			settingsSaver->endGroup();
+		}
 		settingsSaver->endGroup();
 	}
 	// Other view settings
diff --git a/openhantek/src/settings.cpp b/openhantek/src/settings.cpp
index 3b24524..d669d32 100644
--- a/openhantek/src/settings.cpp
+++ b/openhantek/src/settings.cpp
@@ -135,9 +135,9 @@ void DsoSettings::setChannelCount(unsigned int channels) {
 			this->view.color.screen.spectrum.insert(channel, this->view.color.screen.voltage[channel].lighter());
 		// Print
 		if(this->view.color.print.voltage.count() <= channel + 1)
-			this->view.color.print.voltage.insert(channel, this->view.color.screen.voltage[channel]);
+			this->view.color.print.voltage.insert(channel, this->view.color.screen.voltage[channel].darker(120));
 		if(this->view.color.print.spectrum.count() <= channel + 1)
-			this->view.color.print.spectrum.insert(channel, this->view.color.print.voltage[channel].darker());
+			this->view.color.print.spectrum.insert(channel, this->view.color.screen.voltage[channel].darker());
 	}
 	
 	// Check if the math channel is missing
--
libgit2 0.21.4