TimeItem: Added mandatory get_x virtual method
[pulseview.git] / pv / view / view.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 #ifdef ENABLE_DECODE
22 #include <libsigrokdecode/libsigrokdecode.h>
23 #endif
24
25 #include <extdef.h>
26
27 #include <cassert>
28 #include <climits>
29 #include <cmath>
30 #include <mutex>
31 #include <unordered_set>
32
33 #include <QApplication>
34 #include <QEvent>
35 #include <QFontMetrics>
36 #include <QMouseEvent>
37 #include <QScrollBar>
38
39 #include <libsigrok/libsigrok.hpp>
40
41 #include "cursorheader.hpp"
42 #include "decodetrace.hpp"
43 #include "header.hpp"
44 #include "logicsignal.hpp"
45 #include "ruler.hpp"
46 #include "signal.hpp"
47 #include "tracegroup.hpp"
48 #include "view.hpp"
49 #include "viewport.hpp"
50
51 #include "pv/session.hpp"
52 #include "pv/data/logic.hpp"
53 #include "pv/data/logicsegment.hpp"
54 #include "pv/util.hpp"
55
56 using boost::shared_lock;
57 using boost::shared_mutex;
58
59 using pv::data::SignalData;
60 using pv::data::Segment;
61 using pv::util::format_time;
62
63 using std::back_inserter;
64 using std::deque;
65 using std::dynamic_pointer_cast;
66 using std::list;
67 using std::lock_guard;
68 using std::max;
69 using std::make_pair;
70 using std::min;
71 using std::pair;
72 using std::set;
73 using std::shared_ptr;
74 using std::unordered_map;
75 using std::unordered_set;
76 using std::vector;
77 using std::weak_ptr;
78
79 namespace pv {
80 namespace view {
81
82 const double View::MaxScale = 1e9;
83 const double View::MinScale = 1e-15;
84
85 const int View::MaxScrollValue = INT_MAX / 2;
86
87 const int View::ScaleUnits[3] = {1, 2, 5};
88
89 const QColor View::CursorAreaColour(220, 231, 243);
90
91 const QSizeF View::LabelPadding(4, 0);
92
93 View::View(Session &session, QWidget *parent) :
94         QAbstractScrollArea(parent),
95         session_(session),
96         viewport_(new Viewport(*this)),
97         ruler_(new Ruler(*this)),
98         cursorheader_(new CursorHeader(*this)),
99         header_(new Header(*this)),
100         scale_(1e-6),
101         offset_(0),
102         v_offset_(0),
103         updating_scroll_(false),
104         tick_period_(0.0),
105         tick_prefix_(0),
106         show_cursors_(false),
107         cursors_(new CursorPair(*this)),
108         hover_point_(-1, -1)
109 {
110         connect(horizontalScrollBar(), SIGNAL(valueChanged(int)),
111                 this, SLOT(h_scroll_value_changed(int)));
112         connect(verticalScrollBar(), SIGNAL(valueChanged(int)),
113                 this, SLOT(v_scroll_value_changed(int)));
114
115         connect(&session_, SIGNAL(signals_changed()),
116                 this, SLOT(signals_changed()));
117         connect(&session_, SIGNAL(capture_state_changed(int)),
118                 this, SLOT(data_updated()));
119         connect(&session_, SIGNAL(data_received()),
120                 this, SLOT(data_updated()));
121         connect(&session_, SIGNAL(frame_ended()),
122                 this, SLOT(data_updated()));
123
124         connect(cursors_->first().get(), SIGNAL(time_changed()),
125                 this, SLOT(marker_time_changed()));
126         connect(cursors_->second().get(), SIGNAL(time_changed()),
127                 this, SLOT(marker_time_changed()));
128
129         connect(header_, SIGNAL(signals_moved()),
130                 this, SLOT(on_signals_moved()));
131
132         connect(header_, SIGNAL(selection_changed()),
133                 cursorheader_, SLOT(clear_selection()));
134         connect(cursorheader_, SIGNAL(selection_changed()),
135                 header_, SLOT(clear_selection()));
136
137         connect(header_, SIGNAL(selection_changed()),
138                 this, SIGNAL(selection_changed()));
139         connect(cursorheader_, SIGNAL(selection_changed()),
140                 this, SIGNAL(selection_changed()));
141
142         connect(this, SIGNAL(hover_point_changed()),
143                 this, SLOT(on_hover_point_changed()));
144
145         connect(&lazy_event_handler_, SIGNAL(timeout()),
146                 this, SLOT(process_sticky_events()));
147         lazy_event_handler_.setSingleShot(true);
148
149         setViewport(viewport_);
150
151         viewport_->installEventFilter(this);
152         ruler_->installEventFilter(this);
153         cursorheader_->installEventFilter(this);
154         header_->installEventFilter(this);
155
156         // Trigger the initial event manually. The default device has signals
157         // which were created before this object came into being
158         signals_changed();
159
160         // make sure the transparent widgets are on the top
161         cursorheader_->raise();
162         header_->raise();
163
164         // Update the zoom state
165         calculate_tick_spacing();
166 }
167
168 Session& View::session()
169 {
170         return session_;
171 }
172
173 const Session& View::session() const
174 {
175         return session_;
176 }
177
178 View* View::view()
179 {
180         return this;
181 }
182
183 const View* View::view() const
184 {
185         return this;
186 }
187
188 Viewport* View::viewport()
189 {
190         return viewport_;
191 }
192
193 const Viewport* View::viewport() const
194 {
195         return viewport_;
196 }
197
198 vector< shared_ptr<TimeItem> > View::time_items() const
199 {
200         vector< shared_ptr<TimeItem> > items;
201         items.push_back(cursors_->first());
202         items.push_back(cursors_->second());
203         return items;
204 }
205
206 double View::scale() const
207 {
208         return scale_;
209 }
210
211 double View::offset() const
212 {
213         return offset_;
214 }
215
216 int View::owner_visual_v_offset() const
217 {
218         return -v_offset_;
219 }
220
221 unsigned int View::depth() const
222 {
223         return 0;
224 }
225
226 unsigned int View::tick_prefix() const
227 {
228         return tick_prefix_;
229 }
230
231 double View::tick_period() const
232 {
233         return tick_period_;
234 }
235
236 void View::zoom(double steps)
237 {
238         zoom(steps, viewport_->width() / 2);
239 }
240
241 void View::zoom(double steps, int offset)
242 {
243         set_zoom(scale_ * pow(3.0/2.0, -steps), offset);
244 }
245
246 void View::zoom_fit()
247 {
248         const pair<double, double> extents = get_time_extents();
249         const double delta = extents.second - extents.first;
250         if (delta < 1e-12)
251                 return;
252
253         assert(viewport_);
254         const int w = viewport_->width();
255         if (w <= 0)
256                 return;
257
258         const double scale = max(min(delta / w, MaxScale), MinScale);
259         set_scale_offset(scale, extents.first);
260 }
261
262 void View::zoom_one_to_one()
263 {
264         using pv::data::SignalData;
265
266         // Make a set of all the visible data objects
267         set< shared_ptr<SignalData> > visible_data = get_visible_data();
268         if (visible_data.empty())
269                 return;
270
271         double samplerate = 0.0;
272         for (const shared_ptr<SignalData> d : visible_data) {
273                 assert(d);
274                 const vector< shared_ptr<Segment> > segments =
275                         d->segments();
276                 for (const shared_ptr<Segment> &s : segments)
277                         samplerate = max(samplerate, s->samplerate());
278         }
279
280         if (samplerate == 0.0)
281                 return;
282
283         assert(viewport_);
284         const int w = viewport_->width();
285         if (w <= 0)
286                 return;
287
288         set_zoom(1.0 / samplerate, w / 2);
289 }
290
291 void View::set_scale_offset(double scale, double offset)
292 {
293         scale_ = scale;
294         offset_ = offset;
295
296         calculate_tick_spacing();
297
298         update_scroll();
299         ruler_->update();
300         cursorheader_->update();
301         viewport_->update();
302         scale_offset_changed();
303 }
304
305 set< shared_ptr<SignalData> > View::get_visible_data() const
306 {
307         shared_lock<shared_mutex> lock(session().signals_mutex());
308         const vector< shared_ptr<Signal> > &sigs(session().signals());
309
310         // Make a set of all the visible data objects
311         set< shared_ptr<SignalData> > visible_data;
312         for (const shared_ptr<Signal> sig : sigs)
313                 if (sig->enabled())
314                         visible_data.insert(sig->data());
315
316         return visible_data;
317 }
318
319 pair<double, double> View::get_time_extents() const
320 {
321         double left_time = DBL_MAX, right_time = DBL_MIN;
322         const set< shared_ptr<SignalData> > visible_data = get_visible_data();
323         for (const shared_ptr<SignalData> d : visible_data)
324         {
325                 const vector< shared_ptr<Segment> > segments =
326                         d->segments();
327                 for (const shared_ptr<Segment> &s : segments) {
328                         double samplerate = s->samplerate();
329                         samplerate = (samplerate <= 0.0) ? 1.0 : samplerate;
330
331                         const double start_time = s->start_time();
332                         left_time = min(left_time, start_time);
333                         right_time = max(right_time, start_time +
334                                 d->get_max_sample_count() / samplerate);
335                 }
336         }
337
338         if (left_time == DBL_MAX && right_time == DBL_MIN)
339                 return make_pair(0.0, 0.0);
340
341         assert(left_time < right_time);
342         return make_pair(left_time, right_time);
343 }
344
345 bool View::cursors_shown() const
346 {
347         return show_cursors_;
348 }
349
350 void View::show_cursors(bool show)
351 {
352         show_cursors_ = show;
353         cursorheader_->update();
354         viewport_->update();
355 }
356
357 void View::centre_cursors()
358 {
359         const double time_width = scale_ * viewport_->width();
360         cursors_->first()->set_time(offset_ + time_width * 0.4);
361         cursors_->second()->set_time(offset_ + time_width * 0.6);
362         cursorheader_->update();
363         viewport_->update();
364 }
365
366 std::shared_ptr<CursorPair> View::cursors() const
367 {
368         return cursors_;
369 }
370
371 const QPoint& View::hover_point() const
372 {
373         return hover_point_;
374 }
375
376 void View::update_viewport()
377 {
378         assert(viewport_);
379         viewport_->update();
380         header_->update();
381 }
382
383 void View::restack_all_row_items()
384 {
385         // Make a set of owners
386         unordered_set< RowItemOwner* > owners;
387         for (const auto &r : *this)
388                 owners.insert(r->owner());
389
390         // Make a list that is sorted from deepest first
391         vector< RowItemOwner* > sorted_owners(owners.begin(), owners.end());
392         sort(sorted_owners.begin(), sorted_owners.end(),
393                 [](const RowItemOwner* a, const RowItemOwner *b) {
394                         return a->depth() > b->depth(); });
395
396         // Restack the items recursively
397         for (auto &o : sorted_owners)
398                 o->restack_items();
399
400         // Animate the items to their destination
401         for (const auto &r : *this)
402                 r->animate_to_layout_v_offset();
403 }
404
405 void View::get_scroll_layout(double &length, double &offset) const
406 {
407         const pair<double, double> extents = get_time_extents();
408         length = (extents.second - extents.first) / scale_;
409         offset = offset_ / scale_;
410 }
411
412 void View::set_zoom(double scale, int offset)
413 {
414         const double cursor_offset = offset_ + scale_ * offset;
415         const double new_scale = max(min(scale, MaxScale), MinScale);
416         const double new_offset = cursor_offset - new_scale * offset;
417         set_scale_offset(new_scale, new_offset);
418 }
419
420 void View::calculate_tick_spacing()
421 {
422         const double SpacingIncrement = 32.0f;
423         const double MinValueSpacing = 32.0f;
424
425         double min_width = SpacingIncrement, typical_width;
426
427         QFontMetrics m(QApplication::font());
428
429         do {
430                 const double min_period = scale_ * min_width;
431
432                 const int order = (int)floorf(log10f(min_period));
433                 const double order_decimal = pow(10.0, order);
434
435                 unsigned int unit = 0;
436
437                 do {
438                         tick_period_ = order_decimal * ScaleUnits[unit++];
439                 } while (tick_period_ < min_period &&
440                         unit < countof(ScaleUnits));
441
442                 tick_prefix_ = (order - pv::util::FirstSIPrefixPower) / 3;
443
444                 typical_width = m.boundingRect(0, 0, INT_MAX, INT_MAX,
445                         Qt::AlignLeft | Qt::AlignTop,
446                         format_time(offset_, tick_prefix_)).width() +
447                                 MinValueSpacing;
448
449                 min_width += SpacingIncrement;
450
451         } while(typical_width > tick_period_ / scale_);
452 }
453
454 void View::update_scroll()
455 {
456         assert(viewport_);
457
458         const QSize areaSize = viewport_->size();
459
460         // Set the horizontal scroll bar
461         double length = 0, offset = 0;
462         get_scroll_layout(length, offset);
463         length = max(length - areaSize.width(), 0.0);
464
465         int major_tick_distance = tick_period_ / scale_;
466
467         horizontalScrollBar()->setPageStep(areaSize.width() / 2);
468         horizontalScrollBar()->setSingleStep(major_tick_distance);
469
470         updating_scroll_ = true;
471
472         if (length < MaxScrollValue) {
473                 horizontalScrollBar()->setRange(0, length);
474                 horizontalScrollBar()->setSliderPosition(offset);
475         } else {
476                 horizontalScrollBar()->setRange(0, MaxScrollValue);
477                 horizontalScrollBar()->setSliderPosition(
478                         offset_ * MaxScrollValue / (scale_ * length));
479         }
480
481         updating_scroll_ = false;
482
483         // Set the vertical scrollbar
484         verticalScrollBar()->setPageStep(areaSize.height());
485
486         const pair<int, int> extents = v_extents();
487         const int extra_scroll_height = (extents.second - extents.first) / 4;
488         verticalScrollBar()->setRange(extents.first - extra_scroll_height,
489                 extents.first + extra_scroll_height);
490 }
491
492 void View::update_layout()
493 {
494         setViewportMargins(
495                 header_->sizeHint().width() - pv::view::Header::BaselineOffset,
496                 ruler_->sizeHint().height(), 0, 0);
497         ruler_->setGeometry(viewport_->x(), 0,
498                 viewport_->width(), viewport_->y());
499         cursorheader_->setGeometry(
500                 viewport_->x(),
501                 ruler_->sizeHint().height() - cursorheader_->sizeHint().height() / 2,
502                 viewport_->width(), cursorheader_->sizeHint().height());
503         header_->setGeometry(0, viewport_->y(),
504                 header_->sizeHint().width(), viewport_->height());
505         update_scroll();
506 }
507
508 void View::paint_label(QPainter &p, const QRect &rect, bool hover)
509 {
510         (void)p;
511         (void)rect;
512         (void)hover;
513 }
514
515 QRectF View::label_rect(const QRectF &rect)
516 {
517         (void)rect;
518         return QRectF();
519 }
520
521 bool View::add_channels_to_owner(
522         const vector< shared_ptr<sigrok::Channel> > &channels,
523         RowItemOwner *owner, int &offset,
524         unordered_map<shared_ptr<sigrok::Channel>, shared_ptr<Signal> >
525                 &signal_map,
526         std::function<bool (shared_ptr<RowItem>)> filter_func)
527 {
528         bool any_added = false;
529
530         assert(owner);
531
532         for (const auto &channel : channels)
533         {
534                 const auto iter = signal_map.find(channel);
535                 if (iter == signal_map.end() ||
536                         (filter_func && !filter_func((*iter).second)))
537                         continue;
538
539                 shared_ptr<RowItem> row_item = (*iter).second;
540                 owner->add_child_item(row_item);
541                 apply_offset(row_item, offset);
542                 signal_map.erase(iter);
543
544                 any_added = true;
545         }
546
547         return any_added;
548 }
549
550 void View::apply_offset(shared_ptr<RowItem> row_item, int &offset) {
551         assert(row_item);
552         const pair<int, int> extents = row_item->v_extents();
553         if (row_item->enabled())
554                 offset += -extents.first;
555         row_item->force_to_v_offset(offset);
556         if (row_item->enabled())
557                 offset += extents.second;
558 }
559
560 bool View::eventFilter(QObject *object, QEvent *event)
561 {
562         const QEvent::Type type = event->type();
563         if (type == QEvent::MouseMove) {
564
565                 const QMouseEvent *const mouse_event = (QMouseEvent*)event;
566                 if (object == viewport_)
567                         hover_point_ = mouse_event->pos();
568                 else if (object == ruler_ || object == cursorheader_)
569                         hover_point_ = QPoint(mouse_event->x(), 0);
570                 else if (object == header_)
571                         hover_point_ = QPoint(0, mouse_event->y());
572                 else
573                         hover_point_ = QPoint(-1, -1);
574
575                 hover_point_changed();
576
577         } else if (type == QEvent::Leave) {
578                 hover_point_ = QPoint(-1, -1);
579                 hover_point_changed();
580         }
581
582         return QObject::eventFilter(object, event);
583 }
584
585 bool View::viewportEvent(QEvent *e)
586 {
587         switch(e->type()) {
588         case QEvent::Paint:
589         case QEvent::MouseButtonPress:
590         case QEvent::MouseButtonRelease:
591         case QEvent::MouseButtonDblClick:
592         case QEvent::MouseMove:
593         case QEvent::Wheel:
594         case QEvent::TouchBegin:
595         case QEvent::TouchUpdate:
596         case QEvent::TouchEnd:
597                 return false;
598
599         default:
600                 return QAbstractScrollArea::viewportEvent(e);
601         }
602 }
603
604 void View::resizeEvent(QResizeEvent*)
605 {
606         update_layout();
607 }
608
609 void View::appearance_changed(bool label, bool content)
610 {
611         if (label)
612                 header_->update();
613         if (content)
614                 viewport_->update();
615 }
616
617 void View::extents_changed(bool horz, bool vert)
618 {
619         sticky_events_ |=
620                 (horz ? SelectableItemHExtentsChanged : 0) |
621                 (vert ? SelectableItemVExtentsChanged : 0);
622         lazy_event_handler_.start();
623 }
624
625 void View::h_scroll_value_changed(int value)
626 {
627         if (updating_scroll_)
628                 return;
629
630         const int range = horizontalScrollBar()->maximum();
631         if (range < MaxScrollValue)
632                 offset_ = scale_ * value;
633         else {
634                 double length = 0, offset;
635                 get_scroll_layout(length, offset);
636                 offset_ = scale_ * length * value / MaxScrollValue;
637         }
638
639         ruler_->update();
640         cursorheader_->update();
641         viewport_->update();
642 }
643
644 void View::v_scroll_value_changed(int value)
645 {
646         v_offset_ = value;
647         header_->update();
648         viewport_->update();
649 }
650
651 void View::signals_changed()
652 {
653         int offset = 0;
654
655         // Populate the traces
656         clear_child_items();
657
658         shared_ptr<sigrok::Device> device = session_.device();
659         assert(device);
660
661         // Collect a set of signals
662         unordered_map<shared_ptr<sigrok::Channel>, shared_ptr<Signal> >
663                 signal_map;
664
665         shared_lock<shared_mutex> lock(session_.signals_mutex());
666         const vector< shared_ptr<Signal> > &sigs(session_.signals());
667
668         for (const shared_ptr<Signal> &sig : sigs)
669                 signal_map[sig->channel()] = sig;
670
671         // Populate channel groups
672         for (auto entry : device->channel_groups())
673         {
674                 const shared_ptr<sigrok::ChannelGroup> &group = entry.second;
675
676                 if (group->channels().size() <= 1)
677                         continue;
678
679                 shared_ptr<TraceGroup> trace_group(new TraceGroup());
680                 int child_offset = 0;
681                 if (add_channels_to_owner(group->channels(),
682                         trace_group.get(), child_offset, signal_map))
683                 {
684                         add_child_item(trace_group);
685                         apply_offset(trace_group, offset);
686                 }
687         }
688
689         // Add the remaining logic channels
690         shared_ptr<TraceGroup> logic_trace_group(new TraceGroup());
691         int child_offset = 0;
692
693         if (add_channels_to_owner(device->channels(),
694                 logic_trace_group.get(), child_offset, signal_map,
695                 [](shared_ptr<RowItem> r) -> bool {
696                         return dynamic_pointer_cast<LogicSignal>(r) != nullptr;
697                         }))
698
699         {
700                 add_child_item(logic_trace_group);
701                 apply_offset(logic_trace_group, offset);
702         }
703
704         // Add the remaining channels
705         add_channels_to_owner(device->channels(), this, offset, signal_map);
706         assert(signal_map.empty());
707
708         // Add decode signals
709 #ifdef ENABLE_DECODE
710         const vector< shared_ptr<DecodeTrace> > decode_sigs(
711                 session().get_decode_signals());
712         for (auto s : decode_sigs) {
713                 add_child_item(s);
714                 apply_offset(s, offset);
715         }
716 #endif
717
718         update_layout();
719 }
720
721 void View::data_updated()
722 {
723         // Update the scroll bars
724         update_scroll();
725
726         // Repaint the view
727         viewport_->update();
728 }
729
730 void View::marker_time_changed()
731 {
732         cursorheader_->update();
733         viewport_->update();
734 }
735
736 void View::on_signals_moved()
737 {
738         update_scroll();
739         signals_moved();
740 }
741
742 void View::process_sticky_events()
743 {
744         if (sticky_events_ & SelectableItemHExtentsChanged)
745                 update_layout();
746         if (sticky_events_ & SelectableItemVExtentsChanged)
747                 restack_all_row_items();
748
749         // Clear the sticky events
750         sticky_events_ = 0;
751 }
752
753 void View::on_hover_point_changed()
754 {
755         for (shared_ptr<RowItem> r : *this)
756                 r->hover_point_changed();
757 }
758
759 } // namespace view
760 } // namespace pv