Move DivePlotDataModel to qt-models

I think with this one I'm finished.

Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com>
Signed-off-by: Dirk Hohndel <dirk@hohndel.org>

2 files changed, 323 insertions, 0 deletions

diff --git a/qt-models/diveplotdatamodel.cpp b/qt-models/diveplotdatamodel.cpp
new file mode 100644
index 000000000..3b3a288b6
--- /dev/null
+++ b/qt-models/diveplotdatamodel.cpp
@@ -0,0 +1,229 @@
+#include "diveplotdatamodel.h"
+#include "dive.h"
+#include "profile.h"
+#include "graphicsview-common.h"
+#include "divelist.h"
+
+DivePlotDataModel::DivePlotDataModel(QObject *parent) : QAbstractTableModel(parent), diveId(0)
+{
+	memset(&pInfo, 0, sizeof(pInfo));
+}
+
+int DivePlotDataModel::columnCount(const QModelIndex &parent) const
+{
+	return COLUMNS;
+}
+
+QVariant DivePlotDataModel::data(const QModelIndex &index, int role) const
+{
+	if ((!index.isValid()) || (index.row() >= pInfo.nr))
+		return QVariant();
+
+	plot_data item = pInfo.entry[index.row()];
+	if (role == Qt::DisplayRole) {
+		switch (index.column()) {
+		case DEPTH:
+			return item.depth;
+		case TIME:
+			return item.sec;
+		case PRESSURE:
+			return item.pressure[0];
+		case TEMPERATURE:
+			return item.temperature;
+		case COLOR:
+			return item.velocity;
+		case USERENTERED:
+			return false;
+		case CYLINDERINDEX:
+			return item.cylinderindex;
+		case SENSOR_PRESSURE:
+			return item.pressure[0];
+		case INTERPOLATED_PRESSURE:
+			return item.pressure[1];
+		case CEILING:
+			return item.ceiling;
+		case SAC:
+			return item.sac;
+		case PN2:
+			return item.pressures.n2;
+		case PHE:
+			return item.pressures.he;
+		case PO2:
+			return item.pressures.o2;
+		case O2SETPOINT:
+			return item.o2setpoint.mbar / 1000.0;
+		case CCRSENSOR1:
+			return item.o2sensor[0].mbar / 1000.0;
+		case CCRSENSOR2:
+			return item.o2sensor[1].mbar / 1000.0;
+		case CCRSENSOR3:
+			return item.o2sensor[2].mbar / 1000.0;
+		case HEARTBEAT:
+			return item.heartbeat;
+		case AMBPRESSURE:
+			return AMB_PERCENTAGE;
+		case GFLINE:
+			return item.gfline;
+		case INSTANT_MEANDEPTH:
+			return item.running_sum;
+		}
+	}
+
+	if (role == Qt::DisplayRole && index.column() >= TISSUE_1 && index.column() <= TISSUE_16) {
+		return item.ceilings[index.column() - TISSUE_1];
+	}
+
+	if (role == Qt::DisplayRole && index.column() >= PERCENTAGE_1 && index.column() <= PERCENTAGE_16) {
+		return item.percentages[index.column() - PERCENTAGE_1];
+	}
+
+	if (role == Qt::BackgroundRole) {
+		switch (index.column()) {
+		case COLOR:
+			return getColor((color_indice_t)(VELOCITY_COLORS_START_IDX + item.velocity));
+		}
+	}
+	return QVariant();
+}
+
+const plot_info &DivePlotDataModel::data() const
+{
+	return pInfo;
+}
+
+int DivePlotDataModel::rowCount(const QModelIndex &parent) const
+{
+	return pInfo.nr;
+}
+
+QVariant DivePlotDataModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+	if (orientation != Qt::Horizontal)
+		return QVariant();
+
+	if (role != Qt::DisplayRole)
+		return QVariant();
+
+	switch (section) {
+	case DEPTH:
+		return tr("Depth");
+	case TIME:
+		return tr("Time");
+	case PRESSURE:
+		return tr("Pressure");
+	case TEMPERATURE:
+		return tr("Temperature");
+	case COLOR:
+		return tr("Color");
+	case USERENTERED:
+		return tr("User entered");
+	case CYLINDERINDEX:
+		return tr("Cylinder index");
+	case SENSOR_PRESSURE:
+		return tr("Pressure S");
+	case INTERPOLATED_PRESSURE:
+		return tr("Pressure I");
+	case CEILING:
+		return tr("Ceiling");
+	case SAC:
+		return tr("SAC");
+	case PN2:
+		return tr("pN₂");
+	case PHE:
+		return tr("pHe");
+	case PO2:
+		return tr("pO₂");
+	case O2SETPOINT:
+		return tr("Setpoint");
+	case CCRSENSOR1:
+		return tr("Sensor 1");
+	case CCRSENSOR2:
+		return tr("Sensor 2");
+	case CCRSENSOR3:
+		return tr("Sensor 3");
+	case AMBPRESSURE:
+		return tr("Ambient pressure");
+	case HEARTBEAT:
+		return tr("Heart rate");
+	case GFLINE:
+		return tr("Gradient factor");
+	case INSTANT_MEANDEPTH:
+		return tr("Mean depth @ s");
+	}
+	if (role == Qt::DisplayRole && section >= TISSUE_1 && section <= TISSUE_16) {
+		return QString("Ceiling: %1").arg(section - TISSUE_1);
+	}
+	if (role == Qt::DisplayRole && section >= PERCENTAGE_1 && section <= PERCENTAGE_16) {
+		return QString("Tissue: %1").arg(section - PERCENTAGE_1);
+	}
+	return QVariant();
+}
+
+void DivePlotDataModel::clear()
+{
+	if (rowCount() != 0) {
+		beginRemoveRows(QModelIndex(), 0, rowCount() - 1);
+		pInfo.nr = 0;
+		diveId = -1;
+		dcNr = -1;
+		endRemoveRows();
+	}
+}
+
+void DivePlotDataModel::setDive(dive *d, const plot_info &info)
+{
+	clear();
+	Q_ASSERT(d != NULL);
+	diveId = d->id;
+	dcNr = dc_number;
+	pInfo = info;
+	beginInsertRows(QModelIndex(), 0, pInfo.nr - 1);
+	endInsertRows();
+}
+
+unsigned int DivePlotDataModel::dcShown() const
+{
+	return dcNr;
+}
+
+#define MAX_PPGAS_FUNC(GAS, GASFUNC)                                  \
+	double DivePlotDataModel::GASFUNC()                           \
+	{                                                             \
+		double ret = -1;                                      \
+		for (int i = 0, count = rowCount(); i < count; i++) { \
+			if (pInfo.entry[i].pressures.GAS > ret)                 \
+				ret = pInfo.entry[i].pressures.GAS;             \
+		}                                                     \
+		return ret;                                           \
+	}
+
+#define MAX_SENSOR_GAS_FUNC(GASFUNC) \
+	double DivePlotDataModel::GASFUNC()	/* CCR: This function finds the largest measured po2 value */ \
+	{					/* by scanning the readings from the three individual o2 sensors. */ \
+		double ret = -1; 		/* This is used for scaling the Y-axis for partial pressures */ \
+		for (int s = 0; s < 3; s++) {	/* when displaying the graphs for individual o2 sensors */ \
+			for (int i = 0, count = rowCount(); i < count; i++) {   /* POTENTIAL PROBLEM: the '3' (no_sensors) is hard-coded here */\
+				if (pInfo.entry[i].o2sensor[s].mbar > ret)      \
+					ret = pInfo.entry[i].o2sensor[s].mbar;  \
+			}							\
+		}								\
+		return (ret / 1000.0);		/* mbar -> bar conversion */				\
+	}
+
+MAX_PPGAS_FUNC(he, pheMax);
+MAX_PPGAS_FUNC(n2, pn2Max);
+MAX_PPGAS_FUNC(o2, po2Max);
+MAX_SENSOR_GAS_FUNC(CCRMax);
+
+void DivePlotDataModel::emitDataChanged()
+{
+	emit dataChanged(QModelIndex(), QModelIndex());
+}
+
+void DivePlotDataModel::calculateDecompression()
+{
+	struct divecomputer *dc = select_dc(&displayed_dive);
+	init_decompression(&displayed_dive);
+	calculate_deco_information(&displayed_dive, dc, &pInfo, false);
+	dataChanged(index(0, CEILING), index(pInfo.nr - 1, TISSUE_16));
+}
diff --git a/qt-models/diveplotdatamodel.h b/qt-models/diveplotdatamodel.h
new file mode 100644
index 000000000..6a1f9bd16
--- /dev/null
+++ b/qt-models/diveplotdatamodel.h
@@ -0,0 +1,94 @@
+#ifndef DIVEPLOTDATAMODEL_H
+#define DIVEPLOTDATAMODEL_H
+
+#include <QAbstractTableModel>
+
+#include "display.h"
+
+struct dive;
+struct plot_data;
+struct plot_info;
+
+class DivePlotDataModel : public QAbstractTableModel {
+	Q_OBJECT
+public:
+	enum {
+		DEPTH,
+		TIME,
+		PRESSURE,
+		TEMPERATURE,
+		USERENTERED,
+		COLOR,
+		CYLINDERINDEX,
+		SENSOR_PRESSURE,
+		INTERPOLATED_PRESSURE,
+		SAC,
+		CEILING,
+		TISSUE_1,
+		TISSUE_2,
+		TISSUE_3,
+		TISSUE_4,
+		TISSUE_5,
+		TISSUE_6,
+		TISSUE_7,
+		TISSUE_8,
+		TISSUE_9,
+		TISSUE_10,
+		TISSUE_11,
+		TISSUE_12,
+		TISSUE_13,
+		TISSUE_14,
+		TISSUE_15,
+		TISSUE_16,
+		PERCENTAGE_1,
+		PERCENTAGE_2,
+		PERCENTAGE_3,
+		PERCENTAGE_4,
+		PERCENTAGE_5,
+		PERCENTAGE_6,
+		PERCENTAGE_7,
+		PERCENTAGE_8,
+		PERCENTAGE_9,
+		PERCENTAGE_10,
+		PERCENTAGE_11,
+		PERCENTAGE_12,
+		PERCENTAGE_13,
+		PERCENTAGE_14,
+		PERCENTAGE_15,
+		PERCENTAGE_16,
+		PN2,
+		PHE,
+		PO2,
+		O2SETPOINT,
+		CCRSENSOR1,
+		CCRSENSOR2,
+		CCRSENSOR3,
+		HEARTBEAT,
+		AMBPRESSURE,
+		GFLINE,
+		INSTANT_MEANDEPTH,
+		COLUMNS
+	};
+	explicit DivePlotDataModel(QObject *parent = 0);
+	virtual int columnCount(const QModelIndex &parent = QModelIndex()) const;
+	virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+	virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+	virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+	void clear();
+	void setDive(struct dive *d, const plot_info &pInfo);
+	const plot_info &data() const;
+	unsigned int dcShown() const;
+	double pheMax();
+	double pn2Max();
+	double po2Max();
+	double CCRMax();
+	void emitDataChanged();
+	void calculateDecompression();
+
+private:
+	struct plot_info pInfo;
+	int diveId;
+	unsigned int dcNr;
+};
+
+#endif // DIVEPLOTDATAMODEL_H