pv/view/viewport.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 <cassert>
  22
  23 #include "view.h"
  24 #include "viewport.h"
  25
  26 #include "signal.h"
  27 #include "../sigsession.h"
  28
  29 #include <QMouseEvent>
  30
  31 using std::abs;
  32 using std::max;
  33 using std::min;
  34 using std::shared_ptr;
  35 using std::vector;
  36
  37 namespace pv {
  38 namespace view {
  39
  40 Viewport::Viewport(View &parent) :
  41         QWidget(&parent),
  42         _view(parent),
  43         _mouse_down_valid(false),
  44         _pinch_zoom_active(false)
  45 {
  46         setAttribute(Qt::WA_AcceptTouchEvents, true);
  47
  48         setMouseTracking(true);
  49         setAutoFillBackground(true);
  50         setBackgroundRole(QPalette::Base);
  51
  52         connect(&_view.session(), SIGNAL(signals_changed()),
  53                 this, SLOT(on_signals_changed()));
  54
  55         connect(&_view, SIGNAL(signals_moved()),
  56                 this, SLOT(on_signals_moved()));
  57
  58         // Trigger the initial event manually. The default device has signals
  59         // which were created before this object came into being
  60         on_signals_changed();
  61 }
  62
  63 int Viewport::get_total_height() const
  64 {
  65         int h = 0;
  66         const vector< shared_ptr<Trace> > traces(_view.get_traces());
  67         for (const shared_ptr<Trace> t : traces) {
  68                 assert(t);
  69                 h = max(t->get_v_offset() + View::SignalHeight, h);
  70         }
  71
  72         return h;
  73 }
  74
  75 void Viewport::paintEvent(QPaintEvent*)
  76 {
  77         const vector< shared_ptr<Trace> > traces(_view.get_traces());
  78
  79         QPainter p(this);
  80         p.setRenderHint(QPainter::Antialiasing);
  81
  82         if (_view.cursors_shown())
  83                 _view.cursors().draw_viewport_background(p, rect());
  84
  85         // Plot the signal
  86         for (const shared_ptr<Trace> t : traces)
  87         {
  88                 assert(t);
  89                 t->paint_back(p, 0, width());
  90         }
  91
  92         for (const shared_ptr<Trace> t : traces)
  93                 t->paint_mid(p, 0, width());
  94
  95         for (const shared_ptr<Trace> t : traces)
  96                 t->paint_fore(p, 0, width());
  97
  98         if (_view.cursors_shown())
  99                 _view.cursors().draw_viewport_foreground(p, rect());
 100
 101         p.end();
 102 }
 103
 104 bool Viewport::event(QEvent *event)
 105 {
 106         switch (event->type()) {
 107         case QEvent::TouchBegin:
 108         case QEvent::TouchUpdate:
 109         case QEvent::TouchEnd:
 110                 if (touchEvent(static_cast<QTouchEvent *>(event)))
 111                         return true;
 112                 break;
 113
 114         default:
 115                 break;
 116         }
 117
 118         return QWidget::event(event);
 119 }
 120
 121 void Viewport::mousePressEvent(QMouseEvent *event)
 122 {
 123         assert(event);
 124
 125         if (event->button() == Qt::LeftButton) {
 126                 _mouse_down_point = event->pos();
 127                 _mouse_down_offset = _view.offset();
 128                 _mouse_down_valid = true;
 129         }
 130 }
 131
 132 void Viewport::mouseReleaseEvent(QMouseEvent *event)
 133 {
 134         assert(event);
 135
 136         if (event->button() == Qt::LeftButton)
 137                 _mouse_down_valid = false;
 138 }
 139
 140 void Viewport::mouseMoveEvent(QMouseEvent *event)
 141 {
 142         assert(event);
 143
 144         if (event->buttons() & Qt::LeftButton) {
 145                 if (!_mouse_down_valid) {
 146                         _mouse_down_point = event->pos();
 147                         _mouse_down_offset = _view.offset();
 148                         _mouse_down_valid = true;
 149                 }
 150
 151                 _view.set_scale_offset(_view.scale(),
 152                         _mouse_down_offset +
 153                         (_mouse_down_point - event->pos()).x() *
 154                         _view.scale());
 155         }
 156 }
 157
 158 void Viewport::mouseDoubleClickEvent(QMouseEvent *event)
 159 {
 160         assert(event);
 161
 162         if (event->buttons() & Qt::LeftButton)
 163                 _view.zoom(2.0, event->x());
 164         else if (event->buttons() & Qt::RightButton)
 165                 _view.zoom(-2.0, event->x());
 166 }
 167
 168 void Viewport::wheelEvent(QWheelEvent *event)
 169 {
 170         assert(event);
 171
 172         if (event->orientation() == Qt::Vertical) {
 173                 // Vertical scrolling is interpreted as zooming in/out
 174                 _view.zoom(event->delta() / 120, event->x());
 175         } else if (event->orientation() == Qt::Horizontal) {
 176                 // Horizontal scrolling is interpreted as moving left/right
 177                 _view.set_scale_offset(_view.scale(),
 178                                        event->delta() * _view.scale()
 179                                        + _view.offset());
 180         }
 181 }
 182
 183 bool Viewport::touchEvent(QTouchEvent *event)
 184 {
 185         QList<QTouchEvent::TouchPoint> touchPoints = event->touchPoints();
 186
 187         if (touchPoints.count() != 2) {
 188                 _pinch_zoom_active = false;
 189                 return false;
 190         }
 191
 192         const QTouchEvent::TouchPoint &touchPoint0 = touchPoints.first();
 193         const QTouchEvent::TouchPoint &touchPoint1 = touchPoints.last();
 194
 195         if (!_pinch_zoom_active ||
 196             (event->touchPointStates() & Qt::TouchPointPressed)) {
 197                 _pinch_offset0 = _view.offset() + _view.scale() * touchPoint0.pos().x();
 198                 _pinch_offset1 = _view.offset() + _view.scale() * touchPoint1.pos().x();
 199                 _pinch_zoom_active = true;
 200         }
 201
 202         double w = touchPoint1.pos().x() - touchPoint0.pos().x();
 203         if (abs(w) >= 1.0) {
 204                 double scale = (_pinch_offset1 - _pinch_offset0) / w;
 205                 if (scale < 0)
 206                         scale = -scale;
 207                 double offset = _pinch_offset0 - touchPoint0.pos().x() * scale;
 208                 if (scale > 0)
 209                         _view.set_scale_offset(scale, offset);
 210         }
 211
 212         if (event->touchPointStates() & Qt::TouchPointReleased) {
 213                 _pinch_zoom_active = false;
 214
 215                 if (touchPoint0.state() & Qt::TouchPointReleased) {
 216                         // Primary touch released
 217                         _mouse_down_valid = false;
 218                 } else {
 219                         // Update the mouse down fields so that continued
 220                         // dragging with the primary touch will work correctly
 221                         _mouse_down_point = touchPoint0.pos().toPoint();
 222                         _mouse_down_offset = _view.offset();
 223                         _mouse_down_valid = true;
 224                 }
 225         }
 226
 227         return true;
 228 }
 229
 230 void Viewport::on_signals_changed()
 231 {
 232         const vector< shared_ptr<Trace> > traces(_view.get_traces());
 233         for (shared_ptr<Trace> t : traces) {
 234                 assert(t);
 235                 connect(t.get(), SIGNAL(visibility_changed()),
 236                         this, SLOT(update()));
 237         }
 238 }
 239
 240 void Viewport::on_signals_moved()
 241 {
 242         update();
 243 }
 244
 245 } // namespace view
 246 } // namespace pv