Setup environment for SRD on Android
[pulseview.git] / pv / view / header.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
19  */
20
21 #include "header.h"
22 #include "view.h"
23
24 #include "signal.h"
25 #include "../sigsession.h"
26
27 #include <assert.h>
28
29 #include <QApplication>
30 #include <QMenu>
31 #include <QMouseEvent>
32 #include <QPainter>
33 #include <QRect>
34
35 #include <pv/widgets/popup.h>
36
37 using std::max;
38 using std::make_pair;
39 using std::pair;
40 using std::shared_ptr;
41 using std::vector;
42
43 namespace pv {
44 namespace view {
45
46 const int Header::Padding = 12;
47 const int Header::BaselineOffset = 5;
48
49 Header::Header(View &parent) :
50         MarginWidget(parent),
51         _dragging(false)
52 {
53         setFocusPolicy(Qt::ClickFocus);
54         setMouseTracking(true);
55
56         connect(&_view.session(), SIGNAL(signals_changed()),
57                 this, SLOT(on_signals_changed()));
58
59         connect(&_view, SIGNAL(signals_moved()),
60                 this, SLOT(on_signals_moved()));
61
62         // Trigger the initial event manually. The default device has signals
63         // which were created before this object came into being
64         on_signals_changed();
65 }
66
67 QSize Header::sizeHint() const
68 {
69         int max_width = 0;
70
71         const vector< shared_ptr<Trace> > traces(_view.get_traces());
72         for (shared_ptr<Trace> t : traces) {
73                 assert(t);
74
75                 if (t->enabled()) {
76                         max_width = max(max_width, (int)t->get_label_rect(0).width());
77                 }
78         }
79
80         return QSize(max_width + Padding + BaselineOffset, 0);
81 }
82
83 shared_ptr<Trace> Header::get_mouse_over_trace(const QPoint &pt)
84 {
85         const int w = width();
86         const vector< shared_ptr<Trace> > traces(_view.get_traces());
87
88         for (const shared_ptr<Trace> t : traces)
89         {
90                 assert(t);
91                 if (t->pt_in_label_rect(0, w, pt))
92                         return t;
93         }
94
95         return shared_ptr<Trace>();
96 }
97
98 void Header::clear_selection()
99 {
100         const vector< shared_ptr<Trace> > traces(_view.get_traces());
101         for (const shared_ptr<Trace> t : traces) {
102                 assert(t);
103                 t->select(false);
104         }
105
106         update();
107 }
108
109 void Header::paintEvent(QPaintEvent*)
110 {
111         // The trace labels are not drawn with the arrows exactly on the
112         // left edge of the widget, because then the selection shadow
113         // would be clipped away.
114         const int w = width() - BaselineOffset;
115         const vector< shared_ptr<Trace> > traces(_view.get_traces());
116
117         QPainter painter(this);
118         painter.setRenderHint(QPainter::Antialiasing);
119
120         const bool dragging = !_drag_traces.empty();
121         for (const shared_ptr<Trace> t : traces)
122         {
123                 assert(t);
124
125                 const bool highlight = !dragging && t->pt_in_label_rect(
126                         0, w, _mouse_point);
127                 t->paint_label(painter, w, highlight);
128         }
129
130         painter.end();
131 }
132
133 void Header::mousePressEvent(QMouseEvent *event)
134 {
135         assert(event);
136
137         const vector< shared_ptr<Trace> > traces(_view.get_traces());
138
139         if (event->button() & Qt::LeftButton) {
140                 _mouse_down_point = event->pos();
141
142                 // Save the offsets of any signals which will be dragged
143                 for (const shared_ptr<Trace> t : traces)
144                         if (t->selected())
145                                 _drag_traces.push_back(
146                                         make_pair(t, t->get_v_offset()));
147         }
148
149         // Select the signal if it has been clicked
150         const shared_ptr<Trace> mouse_over_trace =
151                 get_mouse_over_trace(event->pos());
152         if (mouse_over_trace) {
153                 if (mouse_over_trace->selected())
154                         mouse_over_trace->select(false);
155                 else {
156                         mouse_over_trace->select(true);
157
158                         if (~QApplication::keyboardModifiers() &
159                                 Qt::ControlModifier)
160                                 _drag_traces.clear();
161
162                         // Add the signal to the drag list
163                         if (event->button() & Qt::LeftButton)
164                                 _drag_traces.push_back(
165                                         make_pair(mouse_over_trace,
166                                         mouse_over_trace->get_v_offset()));
167                 }
168         }
169
170         if (~QApplication::keyboardModifiers() & Qt::ControlModifier) {
171                 // Unselect all other signals because the Ctrl is not
172                 // pressed
173                 for (const shared_ptr<Trace> t : traces)
174                         if (t != mouse_over_trace)
175                                 t->select(false);
176         }
177
178         selection_changed();
179         update();
180 }
181
182 void Header::mouseReleaseEvent(QMouseEvent *event)
183 {
184         using pv::widgets::Popup;
185
186         assert(event);
187         if (event->button() == Qt::LeftButton) {
188                 if (_dragging)
189                         _view.normalize_layout();
190                 else
191                 {
192                         const shared_ptr<Trace> mouse_over_trace =
193                                 get_mouse_over_trace(event->pos());
194                         if (mouse_over_trace) {
195                                 const int w = width() - BaselineOffset;
196                                 Popup *const p =
197                                         mouse_over_trace->create_popup(&_view);
198                                 p->set_position(mapToGlobal(QPoint(w,
199                                         mouse_over_trace->get_y())),
200                                         Popup::Right);
201                                 p->show();
202                         }
203                 }
204
205                 _dragging = false;
206                 _drag_traces.clear();
207         }
208 }
209
210 void Header::mouseMoveEvent(QMouseEvent *event)
211 {
212         assert(event);
213         _mouse_point = event->pos();
214
215         if (!(event->buttons() & Qt::LeftButton))
216                 return;
217
218         if ((event->pos() - _mouse_down_point).manhattanLength() <
219                 QApplication::startDragDistance())
220                 return;
221
222         // Move the signals if we are dragging
223         if (!_drag_traces.empty())
224         {
225                 _dragging = true;
226
227                 const int delta = event->pos().y() - _mouse_down_point.y();
228
229                 for (auto i = _drag_traces.begin(); i != _drag_traces.end(); i++) {
230                         const std::shared_ptr<Trace> trace((*i).first);
231                         if (trace) {
232                                 const int y = (*i).second + delta;
233                                 const int y_snap =
234                                         ((y + View::SignalSnapGridSize / 2) /
235                                                 View::SignalSnapGridSize) *
236                                                 View::SignalSnapGridSize;
237                                 trace->set_v_offset(y_snap);
238
239                                 // Ensure the trace is selected
240                                 trace->select();
241                         }
242                         
243                 }
244
245                 signals_moved();
246         }
247
248         update();
249 }
250
251 void Header::leaveEvent(QEvent*)
252 {
253         _mouse_point = QPoint(-1, -1);
254         update();
255 }
256
257 void Header::contextMenuEvent(QContextMenuEvent *event)
258 {
259         const shared_ptr<Trace> t = get_mouse_over_trace(_mouse_point);
260
261         if (t)
262                 t->create_context_menu(this)->exec(event->globalPos());
263 }
264
265 void Header::keyPressEvent(QKeyEvent *e)
266 {
267         assert(e);
268
269         switch (e->key())
270         {
271         case Qt::Key_Delete:
272         {
273                 const vector< shared_ptr<Trace> > traces(_view.get_traces());
274                 for (const shared_ptr<Trace> t : traces)
275                         if (t->selected())
276                                 t->delete_pressed();    
277                 break;
278         }
279         }
280 }
281
282 void Header::on_signals_changed()
283 {
284         const vector< shared_ptr<Trace> > traces(_view.get_traces());
285         for (shared_ptr<Trace> t : traces) {
286                 assert(t);
287                 connect(t.get(), SIGNAL(visibility_changed()),
288                         this, SLOT(on_trace_changed()));
289                 connect(t.get(), SIGNAL(text_changed()),
290                         this, SLOT(on_trace_changed()));
291                 connect(t.get(), SIGNAL(colour_changed()),
292                         this, SLOT(update()));
293         }
294 }
295
296 void Header::on_signals_moved()
297 {
298         update();
299 }
300
301 void Header::on_trace_changed()
302 {
303         update();
304         geometry_updated();
305 }
306
307 } // namespace view
308 } // namespace pv