BrewPlot 1.0 release

BrewPlot.pro

@@ -0,0 +1,36 @@
+# Add more folders to ship with the application, here
+folder_01.source = qml/BrewPlot
+folder_01.target = qml
+DEPLOYMENTFOLDERS = folder_01
+
+# Additional import path used to resolve QML modules in Creator's code model
+QML_IMPORT_PATH =
+
+symbian:TARGET.UID3 = 0xE41BFE6C
+
+# Allow network access on Symbian
+symbian:TARGET.CAPABILITY += NetworkServices
+
+# Define QMLJSDEBUGGER to allow debugging of QML in debug builds
+# (This might significantly increase build time)
+# DEFINES += QMLJSDEBUGGER
+
+# If your application uses the Qt Mobility libraries, uncomment
+# the following lines and add the respective components to the 
+# MOBILITY variable. 
+# CONFIG += mobility
+# MOBILITY +=
+
+# The .cpp file which was generated for your project. Feel free to hack it.
+SOURCES += main.cpp \
+    qmllineitem.cpp
+
+# Please do not modify the following two lines. Required for deployment.
+include(qmlapplicationviewer/qmlapplicationviewer.pri)
+qtcAddDeployment()
+
+HEADERS += \
+    qmllineitem.h
+
+RESOURCES += \
+    qmlfiles.qrc

main.cpp

@@ -0,0 +1,59 @@
+#include <QtGui>
+#include <QtDeclarative>
+#include "qmlapplicationviewer.h"
+#include "qmllineitem.h"
+
+class QmlWindow : public QMainWindow
+{
+    Q_OBJECT
+public:
+    QmlWindow(QWidget *parent = NULL);
+    Q_INVOKABLE QAction *addMenuItem(QString menu, QString item);
+private:
+    QHash<QString,QMenu *> menus;
+};
+
+QmlWindow::QmlWindow(QWidget *parent) : QMainWindow(parent)
+{
+
+}
+
+QAction *QmlWindow::addMenuItem(QString menu, QString item)
+{
+    QMenu *theMenu;
+    if(menus.contains(menu))
+    {
+        theMenu = menus.value(menu);
+    }
+    else
+    {
+        theMenu = menuBar()->addMenu(menu);
+        menus.insert(menu, theMenu);
+    }
+    return theMenu->addAction(item);
+}
+
+QML_DECLARE_TYPE(QmlWindow)
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+
+    qmlRegisterType<QmlLineItem>("CustomComponents", 1, 0, "Line");
+    qmlRegisterType<QmlWindow>("CustomComponents", 1, 0, "Window");
+
+    QmlWindow *window = new QmlWindow(NULL);
+    window->setWindowTitle("BrewPlot");
+    QmlApplicationViewer *viewer = new QmlApplicationViewer;
+    viewer->setOrientation(QmlApplicationViewer::ScreenOrientationAuto);
+    viewer->rootContext()->setContextProperty("window", window);
+    viewer->setSource(QUrl("qrc:/qml/qml/BrewPlot/main.qml"));
+    app.connect(viewer->engine(), SIGNAL(quit()), SLOT(quit()));
+    window->setCentralWidget(viewer);
+    viewer->setMinimumSize(viewer->sizeHint());
+    window->show();
+
+    return app.exec();
+}
+
+#include "moc_main.cpp"

qml/BrewPlot/BrewingControlChart.qml

@@ -0,0 +1,272 @@
+import CustomComponents 1.0
+import QtQuick 1.0
+
+Item {
+	id: chartOuter
+
+	function plotPoint(px, py, pcolor) {
+		chart.plotPoint(px, py, pcolor);
+	}
+	function setFit(x1, y1, x2, y2) {
+		chart.setFit(x1, y1, x2, y2)
+	}
+	function setFitVisible(visible) {
+		fitline.visible = visible
+	}
+	function setFitColor(color) {
+		fitline.color = color
+	}
+	function clear() {
+		points.clear();
+	}
+
+	Item {
+		id: chart
+		height: parent.height
+		width: parent.width
+
+		function plotPoint(px, py, pcolor) {
+			points.append({"px": px, "py": py, "pcolor": pcolor});
+		}
+		function mapToX(px) {
+			return (chart.width / xrange) * (px - xmin)
+		}
+		function mapToY(py) {
+			return chart.height - ((chart.height / yrange) * (py - ymin))
+		}
+		function setFit(x1, y1, x2, y2) {
+			fitline.x1 = mapToX(x1);
+			fitline.x2 = mapToX(x2);
+			fitline.y1 = mapToY(y1);
+			fitline.y2 = mapToY(y2);
+		}
+		Line {
+			id: fitline
+
+			x1: 0
+			x2: 0
+			y1: 0
+			y2: 0
+			color: "red"
+			visible: false
+		}
+		ListModel {
+			id: xGridLines
+		}
+		ListModel {
+			id: yGridLines
+		}
+		ListModel {
+			id: points
+		}
+
+		Repeater {
+			model: xGridLines
+
+			Line {
+				x1: (chart.width / xrange) * (value - xmin)
+				x2: x1
+				y1: 0
+				y2: chart.height
+				penWidth: pwidth
+				color: "black"
+			}
+		}
+		Repeater {
+			model: yGridLines
+
+			Line {
+				x1: 0
+				x2: chart.width
+				y1: chart.height - ((chart.height / yrange) * (value - ymin))
+				y2: y1
+				penWidth: pwidth
+				color: "black"
+			}
+		}
+		Repeater {
+			model: points
+
+			Item {
+				Rectangle {
+					x: ((chart.width / xrange) * (px - xmin)) - (width / 2)
+					y: chart.height - ((chart.height / yrange) * (py - ymin)) - (height / 2)
+					width: 5
+					height: 5
+					color: pcolor
+					smooth: true
+				}
+			}
+		}
+	}
+	
+	property real xmin: 0.14
+	property real xmax: 0.26
+	property real ymin: 0.008
+	property real ymax: 0.016
+	property real xrange: xmax - xmin
+	property real yrange: ymax - ymin
+	
+	Item {
+		id: yLabels
+
+        anchors.right: chart.left
+        anchors.rightMargin: 10
+        y: chart.y
+        Text {
+            text: "0.8%"
+            y: chart.mapToY(0.008) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "0.9%"
+            y: chart.mapToY(0.009) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.0%"
+            y: chart.mapToY(0.01) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.1%"
+            y: chart.mapToY(0.011) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.2%"
+            y: chart.mapToY(0.012) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.3%"
+            y: chart.mapToY(0.013) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.4%"
+            y: chart.mapToY(0.014) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.5%"
+            y: chart.mapToY(0.015) - (height/2)
+            x: -width
+        }
+        Text {
+            text: "1.6%"
+            y: chart.mapToY(0.016) - (height/2)
+            x: -width
+        }
+    }
+    Item {
+        id: xLabels
+
+        x: chart.x
+        anchors.top: chart.bottom
+        anchors.topMargin: 10
+        Text {
+            text: "14%"
+            x: chart.mapToX(0.14) - (width/2)
+        }
+        Text {
+            text: "15%"
+            x: chart.mapToX(0.15) - (width/2)
+        }
+        Text {
+            text: "16%"
+            x: chart.mapToX(0.16) - (width/2)
+        }
+        Text {
+            text: "17%"
+            x: chart.mapToX(0.17) - (width/2)
+        }
+        Text {
+            text: "18%"
+            x: chart.mapToX(0.18) - (width/2)
+        }
+        Text {
+            text: "19%"
+            x: chart.mapToX(0.19) - (width/2)
+        }
+        Text {
+            text: "20%"
+            x: chart.mapToX(0.2) - (width/2)
+        }
+        Text {
+            text: "21%"
+            x: chart.mapToX(0.21) - (width/2)
+        }
+        Text {
+            text: "22%"
+            x: chart.mapToX(0.22) - (width/2)
+        }
+        Text {
+            text: "23%"
+            x: chart.mapToX(0.23) - (width/2)
+        }
+        Text {
+            text: "24%"
+            x: chart.mapToX(0.24) - (width/2)
+        }
+        Text {
+            text: "25%"
+            x: chart.mapToX(0.25) - (width/2)
+        }
+        Text {
+            text: "26%"
+            x: chart.mapToX(0.26) - (width/2)
+        }
+    }
+    Text {
+        text: "EXTRACTION - Solubles Yield"
+        x: chart.x + (chart.width/2) - (width/2)
+        anchors.top: xLabels.bottom
+        anchors.topMargin: 20
+    }
+    Item {
+        anchors.right: yLabels.left
+        anchors.rightMargin: 40
+        y: chart.y + (chart.height/2) - (strengthLabel.height/2)
+        Text {
+            id: strengthLabel
+
+            text: "STRENGTH - Solubles Concentration (%TDS)"
+            rotation: -90
+            x: -(width/2)
+        }
+    }
+	Component.onCompleted: {
+		xGridLines.append({"value": 0.14, "pwidth": 1})
+		xGridLines.append({"value": 0.15, "pwidth": 1})
+		xGridLines.append({"value": 0.16, "pwidth": 1})
+		xGridLines.append({"value": 0.17, "pwidth": 1})
+		xGridLines.append({"value": 0.18, "pwidth": 2})
+		xGridLines.append({"value": 0.19, "pwidth": 1})
+		xGridLines.append({"value": 0.20, "pwidth": 1})
+		xGridLines.append({"value": 0.21, "pwidth": 1})
+		xGridLines.append({"value": 0.22, "pwidth": 2})
+		xGridLines.append({"value": 0.23, "pwidth": 1})
+		xGridLines.append({"value": 0.24, "pwidth": 1})
+		xGridLines.append({"value": 0.25, "pwidth": 1})
+		xGridLines.append({"value": 0.26, "pwidth": 1})
+		
+		yGridLines.append({"value": 0.008, "pwidth": 1})
+		yGridLines.append({"value": 0.0085, "pwidth": 1})
+		yGridLines.append({"value": 0.009, "pwidth": 1})
+		yGridLines.append({"value": 0.0095, "pwidth": 1})
+		yGridLines.append({"value": 0.01, "pwidth": 1})
+		yGridLines.append({"value": 0.0105, "pwidth": 1})
+		yGridLines.append({"value": 0.011, "pwidth": 1})
+		yGridLines.append({"value": 0.0115, "pwidth": 2})
+		yGridLines.append({"value": 0.012, "pwidth": 1})
+		yGridLines.append({"value": 0.0125, "pwidth": 1})
+		yGridLines.append({"value": 0.013, "pwidth": 1})
+		yGridLines.append({"value": 0.0135, "pwidth": 2})
+		yGridLines.append({"value": 0.014, "pwidth": 1})
+		yGridLines.append({"value": 0.0145, "pwidth": 1})
+		yGridLines.append({"value": 0.015, "pwidth": 1})
+		yGridLines.append({"value": 0.0155, "pwidth": 1})
+		yGridLines.append({"value": 0.016, "pwidth": 1})
+	}
+}

qml/BrewPlot/ColorPicker.qml

@@ -0,0 +1,74 @@
+import QtQuick 1.0
+
+Rectangle {
+	id: colorpicker
+	
+	color: "red"
+	Rectangle {
+		id: pickControl
+		
+		x: 40
+		y: 0
+		z: 10
+		width: 260
+		height: 50
+		color: "white"
+		border.color: "black"
+		border.width: 3
+		radius: 5
+		opacity: 0
+		
+		Behavior on opacity {
+			PropertyAnimation {
+				duration: 250
+			}
+		}
+		Repeater {
+			model: ListModel {
+			
+				ListElement {
+					theColor: "red"
+				}
+				ListElement {
+					theColor: "orange"
+				}
+				ListElement {
+					theColor: "yellow"
+				}
+				ListElement {
+					theColor: "green"
+				}
+				ListElement {
+					theColor: "blue"
+				}
+				ListElement {
+					theColor: "indigo"
+				}
+				ListElement {
+					theColor: "violet"
+				}
+			}
+			Rectangle {
+				width: 30
+				height: 30
+				x: (35*index)+10
+				y: 10
+				color: theColor
+				opacity: 1
+				MouseArea {
+					anchors.fill: parent
+					onClicked: {
+						pickControl.opacity = 0
+						colorpicker.color = parent.color
+					}
+				}
+			}
+		}
+	}
+	MouseArea {
+		anchors.fill: parent
+		onClicked: {
+			pickControl.opacity = 1
+		}
+	}
+}

qml/BrewPlot/main.qml

@@ -0,0 +1,238 @@
+import CustomComponents 1.0
+import QtQuick 1.0
+
+Rectangle {
+    id: root
+
+    property real sumy : 0
+    property real sumxsq : 0
+    property real sumx : 0
+    property real sumxy : 0
+    property int n : 0
+
+    width: 720
+    height: 680
+    Component.onCompleted: {
+        var quitItem = window.addMenuItem("File", "Quit");
+        quitItem.shortcut = "Ctrl+Q";
+        quitItem.triggered.connect(function() {
+                                       Qt.quit();
+                                   });
+        var clearItem = window.addMenuItem("Plotting", "Clear Data");
+        clearItem.triggered.connect(function() {
+                                        graph.clear();
+                                        dataViewModel.clear();
+                                        root.sumy = 0;
+                                        root.sumxsq = 0;
+                                        root.sumx = 0;
+                                        root.sumxy = 0;
+                                        root.n = 0;
+                                        graph.setFit(0, 0, 0, 0);
+                                    });
+        var showLeastSquares = window.addMenuItem("Plotting", "Least Squares Fit");
+        showLeastSquares.checkable = true;
+        showLeastSquares.triggered.connect(function() {
+                                               graph.setFitVisible(showLeastSquares.checked);
+                                               lsfrow.visible = showLeastSquares.checked;
+                                           });
+    }
+    BrewingControlChart {
+        id: graph
+
+        width: 450
+        height: 600
+        anchors.right: parent.right
+        anchors.rightMargin: 20
+        anchors.top: parent.top
+        anchors.topMargin: 20
+    }
+    Item {
+        anchors.left: parent.left
+        anchors.leftMargin: 10
+        anchors.top: parent.top
+        anchors.topMargin: 10
+        Column {
+            spacing: 8
+            Row {
+                spacing: 5
+                Text {
+                    text: "Mass of ground coffee: "
+                }
+                TextInput {
+                    id: groundMass
+
+                    width: 30
+                    validator: DoubleValidator {
+                        bottom: 0
+                        decimals: 2
+                        notation: DoubleValidator.StandardNotation
+                    }
+
+                    Line {
+                        x1: -3
+                        x2: 33
+                        y1: groundMass.height
+                        y2: y1
+                        penWidth: 1
+                        color: "black"
+                    }
+                }
+            }
+            Row {
+                spacing: 5
+                Text {
+                    text: "Mass of brewed coffee:"
+                }
+                TextInput {
+                    id: brewedMass
+
+                    width: 30
+                    validator: DoubleValidator {
+                        bottom: 0
+                        decimals: 2
+                        notation: DoubleValidator.StandardNotation
+                    }
+
+                    Line {
+                        x1: -3
+                        x2: 33
+                        y1: brewedMass.height
+                        y2: y1
+                        penWidth: 1
+                        color: "black"
+                    }
+                }
+            }
+            Row {
+                spacing: 56
+                Text {
+                    text: "Percent TDS:"
+                }
+                TextInput {
+                    id: ptds
+                    width: 30
+                    validator: DoubleValidator {
+                        bottom: 0
+                        top: 100
+                        decimals: 2
+                        notation: DoubleValidator.StandardNotation
+                    }
+                    Line {
+                        x1: -3
+                        x2: 33
+                        y1: ptds.height
+                        y2: y1
+                        penWidth: 1
+                        color: "black"
+                    }
+                }
+            }
+            Row {
+                spacing: 87
+                Text {
+                    id: colorlabel
+                    text: "Color:"
+                }
+                ColorPicker {
+                    id: colorpicker
+                    width: 37
+                    height: colorlabel.height
+                }
+            }
+            Row {
+                id: lsfrow
+                visible: false
+
+                spacing: 1
+                Text {
+                    id: fitcolorlabel
+                    text: "Least Squares Fit Color:"
+                }
+                ColorPicker {
+                    id: fitcolorpicker
+                    width: 37
+                    height: colorlabel.height
+                    onColorChanged: {
+                        graph.setFitColor(color)
+                    }
+                }
+            }
+            Rectangle {
+                z: 0
+                anchors.horizontalCenter: parent.horizontalCenter
+                height: buttonText.height + 20
+                width: buttonText.width + 40
+                border.color: "black"
+                radius: 10
+                Text {
+                    id: buttonText
+
+                    text: "Plot This Brew"
+                    anchors.horizontalCenter: parent.horizontalCenter
+                    anchors.verticalCenter: parent.verticalCenter
+                }
+                MouseArea {
+                    anchors.fill: parent
+                    onClicked: {
+                        var extraction = (brewedMass.text * (ptds.text / 100)) / groundMass.text
+                        graph.plotPoint(extraction, (ptds.text / 100), colorpicker.color)
+                        dataViewModel.append({"color": colorpicker.color, "ptds": ptds.text, "extraction": extraction})
+                        root.n += 1
+                        root.sumy += (ptds.text / 100)
+                        root.sumx += extraction
+                        root.sumxy += ((ptds.text / 100) * extraction)
+                        root.sumxsq += Math.pow(extraction, 2)
+                        if(root.n > 1) {
+                            var a = ((root.sumy * root.sumxsq)-(root.sumx * root.sumxy))/((root.n * root.sumxsq)-Math.pow(root.sumx, 2))
+                            var b = ((root.n * root.sumxy)-(root.sumx * root.sumy))/((root.n * root.sumxsq) - Math.pow(root.sumx, 2))
+                            var x1 = 0.14
+                            var x2 = 0.26
+                            var y1 = a + (b * x1)
+                            var y2 = a + (b * x2)
+                            if(y1 < 0.008) {
+                                x1 = (0.008 - a) / b
+                                y1 = 0.008
+                            }
+                            if(y2 < 0.008) {
+                                x2 = (0.008 - a) / b
+                                y2 = 0.008
+                            }
+                            if(y1 > 0.016) {
+                                x1 = (0.016 - a) / b
+                                y1 = 0.016
+                            }
+                            if(y2 > 0.016) {
+                                x2 = (0.016 - a) / b
+                                y2 = 0.016
+                            }
+                            graph.setFit(x1, y1, x2, y2);
+                        }
+                    }
+                }
+            }
+            Repeater {
+                id: dataView
+
+                model: ListModel {
+                    id: dataViewModel
+                }
+                delegate: Row {
+                    spacing: 3
+                    Rectangle {
+                        width: 30
+                        height: 30
+                        color: dataViewModel.get(index).color
+                    }
+                    Column {
+                        Text {
+                            text: "Strength: "+dataViewModel.get(index).ptds+"% TDS"
+                        }
+                        Text {
+                            text: "Extraction: "+Number(dataViewModel.get(index).extraction*100).toFixed(2)+"%"
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

qmlapplicationviewer/qmlapplicationviewer.cpp

@@ -0,0 +1,174 @@
+// checksum 0x3fbf version 0x70013
+/*
+  This file was generated by the Qt Quick Application wizard of Qt Creator.
+  QmlApplicationViewer is a convenience class containing mobile device specific
+  code such as screen orientation handling. Also QML paths and debugging are
+  handled here.
+  It is recommended not to modify this file, since newer versions of Qt Creator
+  may offer an updated version of it.
+*/
+
+#include "qmlapplicationviewer.h"
+
+#include <QDir>
+#include <QFileInfo>
+#include <QApplication>
+#include <QDeclarativeComponent>
+#include <QDeclarativeEngine>
+#include <QDeclarativeContext>
+
+#include <qplatformdefs.h> // MEEGO_EDITION_HARMATTAN
+
+#ifdef HARMATTAN_BOOSTER
+#include <MDeclarativeCache>
+#endif
+
+#if defined(QMLJSDEBUGGER) && QT_VERSION < 0x040800
+
+#include <qt_private/qdeclarativedebughelper_p.h>
+
+#if !defined(NO_JSDEBUGGER)
+#include <jsdebuggeragent.h>
+#endif
+#if !defined(NO_QMLOBSERVER)
+#include <qdeclarativeviewobserver.h>
+#endif
+
+// Enable debugging before any QDeclarativeEngine is created
+struct QmlJsDebuggingEnabler
+{
+    QmlJsDebuggingEnabler()
+    {
+        QDeclarativeDebugHelper::enableDebugging();
+    }
+};
+
+// Execute code in constructor before first QDeclarativeEngine is instantiated
+static QmlJsDebuggingEnabler enableDebuggingHelper;
+
+#endif // QMLJSDEBUGGER
+
+class QmlApplicationViewerPrivate
+{
+    QString mainQmlFile;
+    friend class QmlApplicationViewer;
+    static QString adjustPath(const QString &path);
+};
+
+QString QmlApplicationViewerPrivate::adjustPath(const QString &path)
+{
+#ifdef Q_OS_UNIX
+#ifdef Q_OS_MAC
+    if (!QDir::isAbsolutePath(path))
+        return QString::fromLatin1("%1/../Resources/%2")
+                .arg(QCoreApplication::applicationDirPath(), path);
+#else
+    const QString pathInInstallDir =
+            QString::fromLatin1("%1/../%2").arg(QCoreApplication::applicationDirPath(), path);
+    if (QFileInfo(pathInInstallDir).exists())
+        return pathInInstallDir;
+#endif
+#endif
+    return path;
+}
+
+QmlApplicationViewer::QmlApplicationViewer(QWidget *parent)
+    : QDeclarativeView(parent)
+    , d(new QmlApplicationViewerPrivate())
+{
+    connect(engine(), SIGNAL(quit()), SLOT(close()));
+    setResizeMode(QDeclarativeView::SizeRootObjectToView);
+    // Qt versions prior to 4.8.0 don't have QML/JS debugging services built in
+#if defined(QMLJSDEBUGGER) && QT_VERSION < 0x040800
+#if !defined(NO_JSDEBUGGER)
+    new QmlJSDebugger::JSDebuggerAgent(engine());
+#endif
+#if !defined(NO_QMLOBSERVER)
+    new QmlJSDebugger::QDeclarativeViewObserver(this, this);
+#endif
+#endif
+}
+
+QmlApplicationViewer::~QmlApplicationViewer()
+{
+    delete d;
+}
+
+QmlApplicationViewer *QmlApplicationViewer::create()
+{
+    return new QmlApplicationViewer();
+}
+
+void QmlApplicationViewer::setMainQmlFile(const QString &file)
+{
+    d->mainQmlFile = QmlApplicationViewerPrivate::adjustPath(file);
+    setSource(QUrl::fromLocalFile(d->mainQmlFile));
+}
+
+void QmlApplicationViewer::addImportPath(const QString &path)
+{
+    engine()->addImportPath(QmlApplicationViewerPrivate::adjustPath(path));
+}
+
+void QmlApplicationViewer::setOrientation(ScreenOrientation orientation)
+{
+#if defined(Q_OS_SYMBIAN)
+    // If the version of Qt on the device is < 4.7.2, that attribute won't work
+    if (orientation != ScreenOrientationAuto) {
+        const QStringList v = QString::fromLatin1(qVersion()).split(QLatin1Char('.'));
+        if (v.count() == 3 && (v.at(0).toInt() << 16 | v.at(1).toInt() << 8 | v.at(2).toInt()) < 0x040702) {
+            qWarning("Screen orientation locking only supported with Qt 4.7.2 and above");
+            return;
+        }
+    }
+#endif // Q_OS_SYMBIAN
+
+    Qt::WidgetAttribute attribute;
+    switch (orientation) {
+#if QT_VERSION < 0x040702
+    // Qt < 4.7.2 does not yet have the Qt::WA_*Orientation attributes
+    case ScreenOrientationLockPortrait:
+        attribute = static_cast<Qt::WidgetAttribute>(128);
+        break;
+    case ScreenOrientationLockLandscape:
+        attribute = static_cast<Qt::WidgetAttribute>(129);
+        break;
+    default:
+    case ScreenOrientationAuto:
+        attribute = static_cast<Qt::WidgetAttribute>(130);
+        break;
+#else // QT_VERSION < 0x040702
+    case ScreenOrientationLockPortrait:
+        attribute = Qt::WA_LockPortraitOrientation;
+        break;
+    case ScreenOrientationLockLandscape:
+        attribute = Qt::WA_LockLandscapeOrientation;
+        break;
+    default:
+    case ScreenOrientationAuto:
+        attribute = Qt::WA_AutoOrientation;
+        break;
+#endif // QT_VERSION < 0x040702
+    };
+    setAttribute(attribute, true);
+}
+
+void QmlApplicationViewer::showExpanded()
+{
+#if defined(Q_OS_SYMBIAN) || defined(MEEGO_EDITION_HARMATTAN) || defined(Q_WS_SIMULATOR)
+    showFullScreen();
+#elif defined(Q_WS_MAEMO_5)
+    showMaximized();
+#else
+    show();
+#endif
+}
+
+QApplication *createApplication(int &argc, char **argv)
+{
+#ifdef HARMATTAN_BOOSTER
+    return MDeclarativeCache::qApplication(argc, argv);
+#else
+    return new QApplication(argc, argv);
+#endif
+}

qmlapplicationviewer/qmlapplicationviewer.h

@@ -0,0 +1,46 @@
+// checksum 0x734b version 0x70013
+/*
+  This file was generated by the Qt Quick Application wizard of Qt Creator.
+  QmlApplicationViewer is a convenience class containing mobile device specific
+  code such as screen orientation handling. Also QML paths and debugging are
+  handled here.
+  It is recommended not to modify this file, since newer versions of Qt Creator
+  may offer an updated version of it.
+*/
+
+#ifndef QMLAPPLICATIONVIEWER_H
+#define QMLAPPLICATIONVIEWER_H
+
+#include <QDeclarativeView>
+
+class QmlApplicationViewer : public QDeclarativeView
+{
+    Q_OBJECT
+
+public:
+    enum ScreenOrientation {
+        ScreenOrientationLockPortrait,
+        ScreenOrientationLockLandscape,
+        ScreenOrientationAuto
+    };
+
+    explicit QmlApplicationViewer(QWidget *parent = 0);
+    virtual ~QmlApplicationViewer();
+
+    static QmlApplicationViewer *create();
+
+    void setMainQmlFile(const QString &file);
+    void addImportPath(const QString &path);
+
+    // Note that this will only have an effect on Symbian and Fremantle.
+    void setOrientation(ScreenOrientation orientation);
+
+    void showExpanded();
+
+private:
+    class QmlApplicationViewerPrivate *d;
+};
+
+QApplication *createApplication(int &argc, char **argv);
+
+#endif // QMLAPPLICATIONVIEWER_H

qmlapplicationviewer/qmlapplicationviewer.pri

@@ -0,0 +1,148 @@
+# checksum 0x5b42 version 0x70013
+# This file was generated by the Qt Quick Application wizard of Qt Creator.
+# The code below adds the QmlApplicationViewer to the project and handles the
+# activation of QML debugging.
+# It is recommended not to modify this file, since newer versions of Qt Creator
+# may offer an updated version of it.
+
+QT += declarative
+
+SOURCES += $$PWD/qmlapplicationviewer.cpp
+HEADERS += $$PWD/qmlapplicationviewer.h
+INCLUDEPATH += $$PWD
+
+# Include JS debugger library if QMLJSDEBUGGER_PATH is set
+!isEmpty(QMLJSDEBUGGER_PATH) {
+    include($$QMLJSDEBUGGER_PATH/qmljsdebugger-lib.pri)
+} else {
+    DEFINES -= QMLJSDEBUGGER
+}
+
+contains(CONFIG,qdeclarative-boostable):contains(MEEGO_EDITION,harmattan) {
+    DEFINES += HARMATTAN_BOOSTER
+}
+# This file was generated by an application wizard of Qt Creator.
+# The code below handles deployment to Symbian and Maemo, aswell as copying
+# of the application data to shadow build directories on desktop.
+# It is recommended not to modify this file, since newer versions of Qt Creator
+# may offer an updated version of it.
+
+defineTest(qtcAddDeployment) {
+for(deploymentfolder, DEPLOYMENTFOLDERS) {
+    item = item$${deploymentfolder}
+    itemsources = $${item}.sources
+    $$itemsources = $$eval($${deploymentfolder}.source)
+    itempath = $${item}.path
+    $$itempath= $$eval($${deploymentfolder}.target)
+    export($$itemsources)
+    export($$itempath)
+    DEPLOYMENT += $$item
+}
+
+MAINPROFILEPWD = $$PWD
+
+symbian {
+    isEmpty(ICON):exists($${TARGET}.svg):ICON = $${TARGET}.svg
+    isEmpty(TARGET.EPOCHEAPSIZE):TARGET.EPOCHEAPSIZE = 0x20000 0x2000000
+} else:win32 {
+    copyCommand =
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source)
+        source = $$replace(source, /, \\)
+        sourcePathSegments = $$split(source, \\)
+        target = $$OUT_PWD/$$eval($${deploymentfolder}.target)/$$last(sourcePathSegments)
+        target = $$replace(target, /, \\)
+        target ~= s,\\\\\\.?\\\\,\\,
+        !isEqual(source,$$target) {
+            !isEmpty(copyCommand):copyCommand += &&
+            isEqual(QMAKE_DIR_SEP, \\) {
+                copyCommand += $(COPY_DIR) \"$$source\" \"$$target\"
+            } else {
+                source = $$replace(source, \\\\, /)
+                target = $$OUT_PWD/$$eval($${deploymentfolder}.target)
+                target = $$replace(target, \\\\, /)
+                copyCommand += test -d \"$$target\" || mkdir -p \"$$target\" && cp -r \"$$source\" \"$$target\"
+            }
+        }
+    }
+    !isEmpty(copyCommand) {
+        copyCommand = @echo Copying application data... && $$copyCommand
+        copydeploymentfolders.commands = $$copyCommand
+        first.depends = $(first) copydeploymentfolders
+        export(first.depends)
+        export(copydeploymentfolders.commands)
+        QMAKE_EXTRA_TARGETS += first copydeploymentfolders
+    }
+} else:unix {
+    maemo5 {
+        desktopfile.files = $${TARGET}.desktop
+        desktopfile.path = /usr/share/applications/hildon
+        icon.files = $${TARGET}64.png
+        icon.path = /usr/share/icons/hicolor/64x64/apps
+    } else:!isEmpty(MEEGO_VERSION_MAJOR) {
+        desktopfile.files = $${TARGET}_harmattan.desktop
+        desktopfile.path = /usr/share/applications
+        icon.files = $${TARGET}80.png
+        icon.path = /usr/share/icons/hicolor/80x80/apps
+    } else { # Assumed to be a Desktop Unix
+        copyCommand =
+        for(deploymentfolder, DEPLOYMENTFOLDERS) {
+            source = $$MAINPROFILEPWD/$$eval($${deploymentfolder}.source)
+            source = $$replace(source, \\\\, /)
+            macx {
+                target = $$OUT_PWD/$${TARGET}.app/Contents/Resources/$$eval($${deploymentfolder}.target)
+            } else {
+                target = $$OUT_PWD/$$eval($${deploymentfolder}.target)
+            }
+            target = $$replace(target, \\\\, /)
+            sourcePathSegments = $$split(source, /)
+            targetFullPath = $$target/$$last(sourcePathSegments)
+            targetFullPath ~= s,/\\.?/,/,
+            !isEqual(source,$$targetFullPath) {
+                !isEmpty(copyCommand):copyCommand += &&
+                copyCommand += $(MKDIR) \"$$target\"
+                copyCommand += && $(COPY_DIR) \"$$source\" \"$$target\"
+            }
+        }
+        !isEmpty(copyCommand) {
+            copyCommand = @echo Copying application data... && $$copyCommand
+            copydeploymentfolders.commands = $$copyCommand
+            first.depends = $(first) copydeploymentfolders
+            export(first.depends)
+            export(copydeploymentfolders.commands)
+            QMAKE_EXTRA_TARGETS += first copydeploymentfolders
+        }
+    }
+    installPrefix = /opt/$${TARGET}
+    for(deploymentfolder, DEPLOYMENTFOLDERS) {
+        item = item$${deploymentfolder}
+        itemfiles = $${item}.files
+        $$itemfiles = $$eval($${deploymentfolder}.source)
+        itempath = $${item}.path
+        $$itempath = $${installPrefix}/$$eval($${deploymentfolder}.target)
+        export($$itemfiles)
+        export($$itempath)
+        INSTALLS += $$item
+    }
+
+    !isEmpty(desktopfile.path) {
+        export(icon.files)
+        export(icon.path)
+        export(desktopfile.files)
+        export(desktopfile.path)
+        INSTALLS += icon desktopfile
+    }
+
+    target.path = $${installPrefix}/bin
+    export(target.path)
+    INSTALLS += target
+}
+
+export (ICON)
+export (INSTALLS)
+export (DEPLOYMENT)
+export (TARGET.EPOCHEAPSIZE)
+export (TARGET.CAPABILITY)
+export (LIBS)
+export (QMAKE_EXTRA_TARGETS)
+}

qmlfiles.qrc

@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/qml">
+        <file>qml/BrewPlot/BrewingControlChart.qml</file>
+        <file>qml/BrewPlot/ColorPicker.qml</file>
+        <file>qml/BrewPlot/main.qml</file>
+    </qresource>
+</RCC>

qmllineitem.cpp

@@ -0,0 +1,133 @@
+#include "qmllineitem.h"
+
+QmlLineItem::QmlLineItem(QDeclarativeItem *parent) :
+    QDeclarativeItem(parent), m_x1(0), m_y1(0), m_x2(0), m_y2(0),
+    m_color(Qt::black), m_penWidth(1)
+{
+    setFlag(QGraphicsItem::ItemHasNoContents, false);
+}
+
+void QmlLineItem::paint(QPainter *painter,
+                        const QStyleOptionGraphicsItem *option,
+                        QWidget *widget)
+{
+    QPen pen(m_color, m_penWidth);
+    painter->setPen(pen);
+    if(smooth() == true)
+    {
+        painter->setRenderHint(QPainter::Antialiasing, true);
+    }
+    int x = qMin(m_x1, m_x2) - m_penWidth/2;
+    int y = qMin(m_y1, m_y2) - m_penWidth/2;
+    painter->drawLine(m_x1 - x, m_y1 - y, m_x2 - x, m_y2 - y);
+}
+
+int QmlLineItem::x1() const
+{
+    return m_x1;
+}
+
+int QmlLineItem::y1() const
+{
+    return m_y1;
+}
+
+int QmlLineItem::x2() const
+{
+    return m_x2;
+}
+
+int QmlLineItem::y2() const
+{
+    return m_y2;
+}
+
+QColor QmlLineItem::color() const
+{
+    return m_color;
+}
+
+int QmlLineItem::penWidth() const
+{
+    return m_penWidth;
+}
+
+
+void QmlLineItem::setX1(int x1)
+{
+    if(m_x1 == x1)
+    {
+        return;
+    }
+    m_x1 = x1;
+    updateSize();
+    emit x1Changed();
+    update();
+}
+
+void QmlLineItem::setY1(int y1)
+{
+    if(m_y1 == y1)
+    {
+        return;
+    }
+    m_y1 = y1;
+    updateSize();
+    emit y1Changed();
+    update();
+}
+
+void QmlLineItem::setX2(int x2)
+{
+    if(m_x2 == x2)
+    {
+        return;
+    }
+    m_x2 = x2;
+    updateSize();
+    emit x2Changed();
+    update();
+}
+
+void QmlLineItem::setY2(int y2)
+{
+    if(m_y2 == y2)
+    {
+        return;
+    }
+    m_y2 = y2;
+    updateSize();
+    emit y2Changed();
+    update();
+}
+
+void QmlLineItem::setColor(const QColor &color)
+{
+    if(m_color == color)
+    {
+        return;
+    }
+    m_color = color;
+    emit colorChanged();
+    update();
+}
+
+void QmlLineItem::setPenWidth(int newWidth)
+{
+    if(m_penWidth == newWidth)
+    {
+        return;
+    }
+    m_penWidth = newWidth;
+    updateSize();
+    emit penWidthChanged();
+    update();
+}
+
+void QmlLineItem::updateSize()
+{
+    setX(qMin(m_x1, m_x2) - m_penWidth/2);
+    setY(qMin(m_y1, m_y2) - m_penWidth/2);
+    setWidth(qAbs(m_x2 - m_x1) + m_penWidth);
+    setHeight(qAbs(m_y2 - m_y1) + m_penWidth);
+}

qmllineitem.h

@@ -0,0 +1,53 @@
+#ifndef QMLLINEITEM_H
+#define QMLLINEITEM_H
+
+#include <QDeclarativeItem>
+#include <QPainter>
+
+class QmlLineItem : public QDeclarativeItem
+{
+    Q_OBJECT
+    Q_PROPERTY(int x1 READ x1 WRITE setX1 NOTIFY x1Changed);
+    Q_PROPERTY(int y1 READ y1 WRITE setY1 NOTIFY y1Changed);
+    Q_PROPERTY(int x2 READ x2 WRITE setX2 NOTIFY x2Changed);
+    Q_PROPERTY(int y2 READ y2 WRITE setY2 NOTIFY y2Changed);
+    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
+    Q_PROPERTY(int penWidth READ penWidth WRITE setPenWidth NOTIFY penWidthChanged);
+public:
+    QmlLineItem(QDeclarativeItem *parent = NULL);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
+               QWidget *widget);
+    int x1() const;
+    int y1() const;
+    int x2() const;
+    int y2() const;
+    QColor color() const;
+    int penWidth() const;
+    void setX1(int x1);
+    void setY1(int y1);
+    void setX2(int x2);
+    void setY2(int y2);
+    void setColor(const QColor &color);
+    void setPenWidth(int newWidth);
+
+signals:
+    void x1Changed();
+    void y1Changed();
+    void x2Changed();
+    void y2Changed();
+    void colorChanged();
+    void penWidthChanged();
+
+private:
+    void updateSize();
+    int m_x1;
+    int m_y1;
+    int m_x2;
+    int m_y2;
+    QColor m_color;
+    int m_penWidth;
+};
+
+QML_DECLARE_TYPE(QmlLineItem)
+
+#endif