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