1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
#ifndef DIVEPLANNER_H
#define DIVEPLANNER_H
#include <QGraphicsView>
#include <QGraphicsPathItem>
#include <QDialog>
#include <QAbstractTableModel>
#include <QDateTime>
#include "dive.h"
namespace Ui{
class DivePlanner;
};
class QListView;
class QStringListModel;
class QModelIndex;
// Return a Model containing the air types.
QStringListModel *airTypes();
class DivePlannerPointsModel : public QAbstractTableModel{
Q_OBJECT
public:
static DivePlannerPointsModel* instance();
enum Sections{REMOVE, DEPTH, DURATION, GAS, CCSETPOINT, COLUMNS};
virtual int columnCount(const QModelIndex& parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
virtual int rowCount(const QModelIndex& parent = QModelIndex()) const;
virtual QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
virtual bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole);
virtual Qt::ItemFlags flags(const QModelIndex& index) const;
void removeSelectedPoints(const QVector<int>& rows);
/**
* @return the row number.
*/
void editStop(int row, divedatapoint newData );
divedatapoint at(int row);
struct diveplan getDiveplan();
public slots:
int addStop(int meters = 0, int minutes = 0,const QString& gas = QString(), int ccpoint = 0 );
void setGFHigh(short gfhigh);
void setGFLow(short ghflow);
void setSurfacePressure(int pressure);
void setBottomSac(int sac);
void setDecoSac(int sac);
void setStartTime(const QTime& t);
void setLastStop6m(bool value);
void createPlan();
void remove(const QModelIndex& index);
void cancelPlan();
void createTemporaryPlan();
void deleteTemporaryPlan();
signals:
void planCreated();
void planCanceled();
private:
explicit DivePlannerPointsModel(QObject* parent = 0);
struct diveplan diveplan;
QVector<divedatapoint> divepoints;
struct dive *tempDive;
void deleteTemporaryPlan(struct divedatapoint *dp);
};
class Button : public QObject, public QGraphicsRectItem {
Q_OBJECT
public:
explicit Button(QObject* parent = 0);
void setText(const QString& text);
void setPixmap(const QPixmap& pixmap);
protected:
virtual void mousePressEvent(QGraphicsSceneMouseEvent* event);
signals:
void clicked();
private:
QGraphicsPixmapItem *icon;
QGraphicsSimpleTextItem *text;
};
class DiveHandler : public QGraphicsEllipseItem{
public:
DiveHandler();
protected:
void mousePressEvent(QGraphicsSceneMouseEvent* event);
};
class Ruler : public QGraphicsLineItem{
public:
Ruler();
void setMinimum(double minimum);
void setMaximum(double maximum);
void setTickInterval(double interval);
void setOrientation(Qt::Orientation orientation);
void setTickSize(qreal size);
void updateTicks();
double minimum() const;
double maximum() const;
qreal valueAt(const QPointF& p);
qreal percentAt(const QPointF& p);
qreal posAtValue(qreal value);
void setColor(const QColor& color);
void setTextColor(const QColor& color);
private:
Qt::Orientation orientation;
QList<QGraphicsLineItem*> ticks;
QList<QGraphicsSimpleTextItem*> labels;
double min;
double max;
double interval;
double posBegin;
double posEnd;
double tickSize;
QColor textColor;
};
class DivePlannerGraphics : public QGraphicsView {
Q_OBJECT
public:
DivePlannerGraphics(QWidget* parent = 0);
protected:
virtual void mouseDoubleClickEvent(QMouseEvent* event);
virtual void showEvent(QShowEvent* event);
virtual void resizeEvent(QResizeEvent* event);
virtual void mouseMoveEvent(QMouseEvent* event);
virtual void mousePressEvent(QMouseEvent* event);
virtual void mouseReleaseEvent(QMouseEvent* event);
bool isPointOutOfBoundaries(const QPointF& point);
qreal fromPercent(qreal percent, Qt::Orientation orientation);
private slots:
void keyEscAction();
void keyDeleteAction();
void keyUpAction();
void keyDownAction();
void keyLeftAction();
void keyRightAction();
void increaseTime();
void increaseDepth();
void decreaseTime();
void decreaseDepth();;
void createDecoStops();
void prepareSelectGas();
void selectGas(const QModelIndex& index);
void pointInserted(const QModelIndex&, int start, int end);
void pointsRemoved(const QModelIndex&, int start, int end);
private:
void moveActiveHandler(const QPointF& pos);
/* This are the lines of the plotted dive. */
QList<QGraphicsLineItem*> lines;
/* This is the user-entered handles. */
QList<DiveHandler *> handles;
/* this is the user-entered gases.
This must be a button, so the
user cna click to choose a new gas.
*/
QList<Button*> gases;
QListView *gasListView;
QStringListModel *gasChoices;
Button *currentGasChoice;
/* those are the lines that follows the mouse. */
QGraphicsLineItem *verticalLine;
QGraphicsLineItem *horizontalLine;
/* This is the handler that's being dragged. */
DiveHandler *activeDraggedHandler;
// When we start to move the handler, this pos is saved.
// so we can revert it later.
QPointF originalHandlerPos;
/* this is the background of the dive, the blue-gradient. */
QGraphicsPolygonItem *diveBg;
/* This is the bottom ruler - the x axis, and it's associated text */
Ruler *timeLine;
QGraphicsSimpleTextItem *timeString;
/* this is the left ruler, the y axis, and it's associated text. */
Ruler *depthLine;
QGraphicsSimpleTextItem *depthString;
/* Buttons */
Button *plusTime; // adds 10 minutes to the time ruler.
Button *plusDepth; // adds 10 meters to the depth ruler.
Button *lessTime; // remove 10 minutes to the time ruler.
Button *lessDepth; // remove 10 meters to the depth ruler.
int minMinutes; // this holds the minimum duration of the dive.
int dpMaxTime; // this is the time of the dive calculated by the deco.
};
class DivePlannerWidget : public QWidget {
Q_OBJECT
public:
explicit DivePlannerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
public slots:
void startTimeChanged(const QTime& time);
void atmPressureChanged(const QString& pressure);
void bottomSacChanged(const QString& bottomSac);
void decoSacChanged(const QString& decosac);
void gflowChanged(const QString& gflow);
void gfhighChanged(const QString& gfhigh);
void lastStopChanged(bool checked);
private:
Ui::DivePlanner *ui;
};
#endif
|
