pv/view/view.hpp

   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 #ifndef PULSEVIEW_PV_VIEWS_TRACEVIEW_VIEW_HPP
  22 #define PULSEVIEW_PV_VIEWS_TRACEVIEW_VIEW_HPP
  23
  24 #include <stdint.h>
  25
  26 #include <list>
  27 #include <memory>
  28 #include <set>
  29 #include <unordered_map>
  30 #include <vector>
  31
  32 #include <QAbstractScrollArea>
  33 #include <QSizeF>
  34 #include <QTimer>
  35
  36 #include <pv/data/signaldata.hpp>
  37 #include <pv/views/viewbase.hpp>
  38 #include <pv/util.hpp>
  39
  40 #include "cursorpair.hpp"
  41 #include "flag.hpp"
  42 #include "tracetreeitemowner.hpp"
  43
  44 namespace sigrok {
  45 class ChannelGroup;
  46 }
  47
  48 namespace pv {
  49
  50 class Session;
  51
  52 namespace views {
  53
  54 namespace TraceView {
  55
  56 class CursorHeader;
  57 class DecodeTrace;
  58 class Header;
  59 class Ruler;
  60 class Signal;
  61 class Trace;
  62 class Viewport;
  63 class TriggerMarker;
  64
  65 class CustomAbstractScrollArea : public QAbstractScrollArea {
  66         Q_OBJECT
  67
  68 public:
  69         CustomAbstractScrollArea(QWidget *parent = 0);
  70         void setViewportMargins(int left, int top, int right, int bottom);
  71         bool viewportEvent(QEvent *event);
  72 };
  73
  74 class View : public ViewBase, public TraceTreeItemOwner {
  75         Q_OBJECT
  76
  77 private:
  78         enum StickyEvents {
  79                 TraceTreeItemHExtentsChanged = 1,
  80                 TraceTreeItemVExtentsChanged = 2
  81         };
  82
  83 private:
  84         static const pv::util::Timestamp MaxScale;
  85         static const pv::util::Timestamp MinScale;
  86
  87         static const int MaxScrollValue;
  88         static const int MaxViewAutoUpdateRate;
  89
  90         static const int ScaleUnits[3];
  91
  92 public:
  93         explicit View(Session &session, QWidget *parent = 0);
  94
  95         Session& session();
  96         const Session& session() const;
  97
  98         /**
  99          * Returns the signals contained in this view.
 100          */
 101         std::unordered_set< std::shared_ptr<Signal> > signals() const;
 102
 103         virtual void clear_signals();
 104
 105         virtual void add_signal(const std::shared_ptr<Signal> signal);
 106
 107 #ifdef ENABLE_DECODE
 108         virtual void clear_decode_signals();
 109
 110         virtual void add_decode_signal(std::shared_ptr<data::SignalBase> signalbase);
 111
 112         virtual void remove_decode_signal(std::shared_ptr<data::SignalBase> signalbase);
 113 #endif
 114
 115         /**
 116          * Returns the view of the owner.
 117          */
 118         virtual View* view();
 119
 120         /**
 121          * Returns the view of the owner.
 122          */
 123         virtual const View* view() const;
 124
 125         Viewport* viewport();
 126
 127         const Viewport* viewport() const;
 128
 129         virtual void save_settings(QSettings &settings) const;
 130
 131         virtual void restore_settings(QSettings &settings);
 132
 133         /**
 134          * Gets a list of time markers.
 135          */
 136         std::vector< std::shared_ptr<TimeItem> > time_items() const;
 137
 138         /**
 139          * Returns the view time scale in seconds per pixel.
 140          */
 141         double scale() const;
 142
 143         /**
 144          * Returns the time offset of the left edge of the view in
 145          * seconds.
 146          */
 147         const pv::util::Timestamp& offset() const;
 148
 149         /**
 150          * Returns the vertical scroll offset.
 151          */
 152         int owner_visual_v_offset() const;
 153
 154         /**
 155          * Sets the visual v-offset.
 156          */
 157         void set_v_offset(int offset);
 158
 159         /**
 160          * Returns the SI prefix to apply to the graticule time markings.
 161          */
 162         pv::util::SIPrefix tick_prefix() const;
 163
 164         /**
 165          * Returns the number of fractional digits shown for the time markings.
 166          */
 167         unsigned int tick_precision() const;
 168
 169         /**
 170          * Returns period of the graticule time markings.
 171          */
 172         const pv::util::Timestamp& tick_period() const;
 173
 174         /**
 175          * Returns the unit of time currently used.
 176          */
 177         util::TimeUnit time_unit() const;
 178
 179         /**
 180          * Returns the number of nested parents that this row item owner has.
 181          */
 182         unsigned int depth() const;
 183
 184         void zoom(double steps);
 185         void zoom(double steps, int offset);
 186
 187         void zoom_fit(bool gui_state);
 188
 189         void zoom_one_to_one();
 190
 191         /**
 192          * Sets the scale and offset.
 193          * @param scale The new view scale in seconds per pixel.
 194          * @param offset The view time offset in seconds.
 195          */
 196         void set_scale_offset(double scale, const pv::util::Timestamp& offset);
 197
 198         std::set< std::shared_ptr<pv::data::SignalData> >
 199                 get_visible_data() const;
 200
 201         std::pair<pv::util::Timestamp, pv::util::Timestamp> get_time_extents() const;
 202
 203         /**
 204          * Enables or disables sticky scrolling, i.e. the view always shows
 205          * the most recent samples when capturing data.
 206          */
 207         void enable_sticky_scrolling(bool state);
 208
 209         /**
 210          * Enables or disables coloured trace backgrounds. If they're not
 211          * coloured then they will use alternating colors.
 212          */
 213         void enable_coloured_bg(bool state);
 214
 215         /**
 216          * Returns true if cursors are displayed. false otherwise.
 217          */
 218         bool cursors_shown() const;
 219
 220         /**
 221          * Shows or hides the cursors.
 222          */
 223         void show_cursors(bool show = true);
 224
 225         /**
 226          * Moves the cursors to a convenient position in the view.
 227          */
 228         void centre_cursors();
 229
 230         /**
 231          * Returns a reference to the pair of cursors.
 232          */
 233         std::shared_ptr<CursorPair> cursors() const;
 234
 235         /**
 236          * Adds a new flag at a specified time.
 237          */
 238         void add_flag(const pv::util::Timestamp& time);
 239
 240         /**
 241          * Removes a flag from the list.
 242          */
 243         void remove_flag(std::shared_ptr<Flag> flag);
 244
 245         /**
 246          * Gets the list of flags.
 247          */
 248         std::vector< std::shared_ptr<Flag> > flags() const;
 249
 250         const QPoint& hover_point() const;
 251
 252         void restack_all_trace_tree_items();
 253
 254 Q_SIGNALS:
 255         void hover_point_changed();
 256
 257         void selection_changed();
 258
 259         /// Emitted when the offset changed.
 260         void offset_changed();
 261
 262         /// Emitted when the scale changed.
 263         void scale_changed();
 264
 265         void sticky_scrolling_changed(bool state);
 266
 267         void always_zoom_to_fit_changed(bool state);
 268
 269         /// Emitted when the tick_prefix changed.
 270         void tick_prefix_changed();
 271
 272         /// Emitted when the tick_precision changed.
 273         void tick_precision_changed();
 274
 275         /// Emitted when the tick_period changed.
 276         void tick_period_changed();
 277
 278         /// Emitted when the time_unit changed.
 279         void time_unit_changed();
 280
 281 public Q_SLOTS:
 282         void trigger_event(util::Timestamp location);
 283
 284 private:
 285         void get_scroll_layout(double &length, pv::util::Timestamp &offset) const;
 286
 287         /**
 288          * Simultaneously sets the zoom and offset.
 289          * @param scale The scale to set the view to in seconds per pixel. This
 290          * value is clamped between MinScale and MaxScale.
 291          * @param offset The offset of the left edge of the view in seconds.
 292          */
 293         void set_zoom(double scale, int offset);
 294
 295         /**
 296          * Find a tick spacing and number formatting that does not cause
 297          * the values to collide.
 298          */
 299         void calculate_tick_spacing();
 300
 301         void update_scroll();
 302
 303         void reset_scroll();
 304
 305         void set_scroll_default();
 306
 307         void update_layout();
 308
 309         TraceTreeItemOwner* find_prevalent_trace_group(
 310                 const std::shared_ptr<sigrok::ChannelGroup> &group,
 311                 const std::unordered_map<std::shared_ptr<data::SignalBase>,
 312                         std::shared_ptr<Signal> > &signal_map);
 313
 314         static std::vector< std::shared_ptr<Trace> >
 315                 extract_new_traces_for_channels(
 316                 const std::vector< std::shared_ptr<sigrok::Channel> > &channels,
 317                 const std::unordered_map<std::shared_ptr<data::SignalBase>,
 318                         std::shared_ptr<Signal> > &signal_map,
 319                 std::set< std::shared_ptr<Trace> > &add_list);
 320
 321         void determine_time_unit();
 322
 323         bool eventFilter(QObject *object, QEvent *event);
 324
 325         void resizeEvent(QResizeEvent *event);
 326
 327 public:
 328         void row_item_appearance_changed(bool label, bool content);
 329         void time_item_appearance_changed(bool label, bool content);
 330
 331         void extents_changed(bool horz, bool vert);
 332
 333 private Q_SLOTS:
 334
 335         void h_scroll_value_changed(int value);
 336         void v_scroll_value_changed();
 337
 338         void signals_changed();
 339         void capture_state_updated(int state);
 340         void data_updated();
 341
 342         void perform_delayed_view_update();
 343
 344         void process_sticky_events();
 345
 346         void on_hover_point_changed();
 347
 348         /**
 349          * Sets the 'offset_' member and emits the 'offset_changed'
 350          * signal if needed.
 351          */
 352         void set_offset(const pv::util::Timestamp& offset);
 353
 354         /**
 355          * Sets the 'scale_' member and emits the 'scale_changed'
 356          * signal if needed.
 357          */
 358         void set_scale(double scale);
 359
 360         /**
 361          * Sets the 'tick_prefix_' member and emits the 'tick_prefix_changed'
 362          * signal if needed.
 363          */
 364         void set_tick_prefix(pv::util::SIPrefix tick_prefix);
 365
 366         /**
 367          * Sets the 'tick_precision_' member and emits the 'tick_precision_changed'
 368          * signal if needed.
 369          */
 370         void set_tick_precision(unsigned tick_precision);
 371
 372         /**
 373          * Sets the 'tick_period_' member and emits the 'tick_period_changed'
 374          * signal if needed.
 375          */
 376         void set_tick_period(const pv::util::Timestamp& tick_period);
 377
 378         /**
 379          * Sets the 'time_unit' member and emits the 'time_unit_changed'
 380          * signal if needed.
 381          */
 382         void set_time_unit(pv::util::TimeUnit time_unit);
 383
 384 private:
 385         Viewport *viewport_;
 386         Ruler *ruler_;
 387         Header *header_;
 388
 389         std::unordered_set< std::shared_ptr<Signal> > signals_;
 390
 391 #ifdef ENABLE_DECODE
 392         std::vector< std::shared_ptr<DecodeTrace> > decode_traces_;
 393 #endif
 394
 395         CustomAbstractScrollArea scrollarea_;
 396
 397         /// The view time scale in seconds per pixel.
 398         double scale_;
 399
 400         /// The view time offset in seconds.
 401         pv::util::Timestamp offset_;
 402
 403         bool updating_scroll_;
 404         bool sticky_scrolling_;
 405         bool always_zoom_to_fit_;
 406         QTimer delayed_view_updater_;
 407
 408         pv::util::Timestamp tick_period_;
 409         pv::util::SIPrefix tick_prefix_;
 410         unsigned int tick_precision_;
 411         util::TimeUnit time_unit_;
 412
 413         bool show_cursors_;
 414         std::shared_ptr<CursorPair> cursors_;
 415
 416         std::list< std::shared_ptr<Flag> > flags_;
 417         char next_flag_text_;
 418
 419         std::vector< std::shared_ptr<TriggerMarker> > trigger_markers_;
 420
 421         QPoint hover_point_;
 422
 423         unsigned int sticky_events_;
 424         QTimer lazy_event_handler_;
 425
 426         // This is true when the defaults couldn't be set due to insufficient info
 427         bool scroll_needs_defaults;
 428 };
 429
 430 } // namespace TraceView
 431 } // namespace views
 432 } // namespace pv
 433
 434 #endif // PULSEVIEW_PV_VIEWS_TRACEVIEW_VIEW_HPP