view.hpp

Go to the documentation of this file.

/*
 * This file is part of the PulseView project.
 *
 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#ifndef PULSEVIEW_PV_VIEWS_TRACE_VIEW_HPP
#define PULSEVIEW_PV_VIEWS_TRACE_VIEW_HPP

#include <cstdint>
#include <list>
#include <memory>
#include <mutex>
#include <set>
#include <vector>

#include <QAbstractScrollArea>
#include <QShortcut>
#include <QSizeF>
#include <QSplitter>

#include <pv/globalsettings.hpp>
#include <pv/util.hpp>
#include <pv/data/signaldata.hpp>
#include <pv/views/viewbase.hpp>

#include "cursorpair.hpp"
#include "flag.hpp"
#include "trace.hpp"
#include "tracetreeitemowner.hpp"

using std::list;
using std::map;
using std::set;
using std::shared_ptr;
using std::vector;

namespace sigrok {
class ChannelGroup;
}

namespace pv {

class Session;

namespace data {
class Logic;
}

namespace views {

namespace trace {

class DecodeTrace;
class Header;
class Ruler;
class Signal;
class Viewport;
class TriggerMarker;

class CustomScrollArea : public QAbstractScrollArea
{
    Q_OBJECT

public:
    CustomScrollArea(QWidget *parent = nullptr);
    bool viewportEvent(QEvent *event);
};

class View : public ViewBase, public TraceTreeItemOwner, public GlobalSettingsInterface
{
    Q_OBJECT

private:
    enum StickyEvents {
        TraceTreeItemHExtentsChanged = 1,
        TraceTreeItemVExtentsChanged = 2
    };

private:
    static const pv::util::Timestamp MaxScale;
    static const pv::util::Timestamp MinScale;

    static const int MaxScrollValue;
    static const int ViewScrollMargin;

    static const int ScaleUnits[3];

public:
    explicit View(Session &session, bool is_main_view=false, QMainWindow *parent = nullptr);

    ~View();

    virtual ViewType get_type() const;

    virtual void reset_view_state();

    Session& session();  // This method is needed for TraceTreeItemOwner, not ViewBase
    const Session& session() const;  // This method is needed for TraceTreeItemOwner, not ViewBase

    vector< shared_ptr<Signal> > signals() const;

    shared_ptr<Signal> get_signal_by_signalbase(shared_ptr<data::SignalBase> base) const;

    virtual void clear_signalbases();
    virtual void add_signalbase(const shared_ptr<data::SignalBase> signalbase);
    virtual void remove_signalbase(const shared_ptr<data::SignalBase> signalbase);

#ifdef ENABLE_DECODE
    virtual void clear_decode_signals();

    virtual void add_decode_signal(shared_ptr<data::DecodeSignal> signal);

    virtual void remove_decode_signal(shared_ptr<data::DecodeSignal> signal);
#endif

    void remove_trace(shared_ptr<Trace> trace);

    shared_ptr<Signal> get_signal_under_mouse_cursor() const;

    virtual View* view();

    virtual const View* view() const;

    Viewport* viewport();
    const Viewport* viewport() const;

    QAbstractScrollArea* scrollarea() const;

    const Ruler* ruler() const;

    virtual void save_settings(QSettings &settings) const;
    virtual void restore_settings(QSettings &settings);

    vector< shared_ptr<TimeItem> > time_items() const;

    double scale() const;

    const pv::util::Timestamp& offset() const;

    const pv::util::Timestamp& ruler_offset() const;

    void set_zero_position(const pv::util::Timestamp& position);

    void reset_zero_position();

    pv::util::Timestamp zero_offset() const;

    int owner_visual_v_offset() const;

    void set_v_offset(int offset);

    void set_h_offset(int offset);

    int get_h_scrollbar_maximum() const;

    pv::util::SIPrefix tick_prefix() const;

    unsigned int tick_precision() const;

    const pv::util::Timestamp& tick_period() const;

    unsigned int minor_tick_count() const;

    util::TimeUnit time_unit() const;

    unsigned int depth() const;

    uint32_t current_segment() const;

    bool segment_is_selectable() const;

    Trace::SegmentDisplayMode segment_display_mode() const;
    void set_segment_display_mode(Trace::SegmentDisplayMode mode);

    void zoom(double steps);
    void zoom(double steps, int offset);

    void zoom_fit(bool gui_state);

    virtual void focus_on_range(uint64_t start_sample, uint64_t end_sample);

    void set_scale_offset(double scale, const pv::util::Timestamp& offset);

    vector< shared_ptr<pv::data::SignalData> > get_visible_data() const;

    pair<pv::util::Timestamp, pv::util::Timestamp> get_time_extents() const;

    bool colored_bg() const;

    bool cursors_shown() const;

    void show_cursors(bool show = true);

    void set_cursors(pv::util::Timestamp& first, pv::util::Timestamp& second);

    void center_cursors();

    shared_ptr<CursorPair> cursors() const;

    shared_ptr<Flag> add_flag(const pv::util::Timestamp& time);

    void remove_flag(shared_ptr<Flag> flag);

    vector< shared_ptr<Flag> > flags() const;

    const QPoint& hover_point() const;
    const QWidget* hover_widget() const;

    int64_t get_nearest_level_change(const QPoint &p);

    void restack_all_trace_tree_items();

    int header_width() const;

    void on_setting_changed(const QString &key, const QVariant &value);

Q_SIGNALS:
    void hover_point_changed(const QWidget* widget, const QPoint &hp);

    void selection_changed();

    void offset_changed();

    void scale_changed();

    void sticky_scrolling_changed(bool state);

    void always_zoom_to_fit_changed(bool state);

    void tick_prefix_changed();

    void tick_precision_changed();

    void tick_period_changed();

    void time_unit_changed();

    void segment_changed(int segment_id);

    void segment_display_mode_changed(int mode, bool segment_selectable);

    void cursor_state_changed(bool show);

public Q_SLOTS:
    void trigger_event(int segment_id, util::Timestamp location);

private:
    void get_scroll_layout(double &length, pv::util::Timestamp &offset) const;

    void set_zoom(double scale, int offset);

    void calculate_tick_spacing();

    void adjust_top_margin();

    void update_scroll();
    void reset_scroll();
    void set_scroll_default();

    void determine_if_header_was_shrunk();

    void resize_header_to_fit();

    void update_layout();

    TraceTreeItemOwner* find_prevalent_trace_group(
        const shared_ptr<sigrok::ChannelGroup> &group,
        const map<shared_ptr<data::SignalBase>, shared_ptr<Signal> > &signal_map);

    static vector< shared_ptr<Trace> >
        extract_new_traces_for_channels(
        const vector< shared_ptr<sigrok::Channel> > &channels,
        const map<shared_ptr<data::SignalBase>, shared_ptr<Signal> > &signal_map,
        set< shared_ptr<Trace> > &add_list);

    void determine_time_unit();

    bool eventFilter(QObject *object, QEvent *event);

    virtual void contextMenuEvent(QContextMenuEvent *event);

    void resizeEvent(QResizeEvent *event);

    void update_view_range_metaobject() const;
    void update_hover_point();

public:
    void row_item_appearance_changed(bool label, bool content);
    void time_item_appearance_changed(bool label, bool content);

    void extents_changed(bool horz, bool vert);

private Q_SLOTS:
    void on_signal_name_changed();
    void on_splitter_moved();

    void on_zoom_in_shortcut_triggered();
    void on_zoom_out_shortcut_triggered();
    void on_scroll_to_start_shortcut_triggered();
    void on_scroll_to_end_shortcut_triggered();

    void h_scroll_value_changed(int value);
    void v_scroll_value_changed();

    void on_grab_ruler(int ruler_id);

    void signals_changed();
    void capture_state_updated(int state);

    void on_new_segment(int new_segment_id);
    void on_segment_completed(int new_segment_id);
    void on_segment_changed(int segment);

    void on_settingViewTriggerIsZeroTime_changed(const QVariant new_value);

    void on_create_marker_here();

    virtual void perform_delayed_view_update();

    void process_sticky_events();

    void set_offset(const pv::util::Timestamp& offset, bool force_update = false);

    void set_scale(double scale);

    void set_tick_prefix(pv::util::SIPrefix tick_prefix);

    void set_tick_precision(unsigned tick_precision);

    void set_tick_period(const pv::util::Timestamp& tick_period);

    void set_time_unit(pv::util::TimeUnit time_unit);

    void set_current_segment(uint32_t segment_id);

private:
    CustomScrollArea *scrollarea_;
    Viewport *viewport_;
    Ruler *ruler_;
    Header *header_;
    QSplitter *splitter_;

    QShortcut *zoom_in_shortcut_, *zoom_in_shortcut_2_;
    QShortcut *zoom_out_shortcut_, *zoom_out_shortcut_2_;
    QShortcut *home_shortcut_, *end_shortcut_;
    QShortcut *grab_ruler_left_shortcut_, *grab_ruler_right_shortcut_;
    QShortcut *cancel_grab_shortcut_;

    mutable mutex signal_mutex_;
    vector< shared_ptr<Signal> > signals_;

#ifdef ENABLE_DECODE
    vector< shared_ptr<DecodeTrace> > decode_traces_;
#endif

    Trace::SegmentDisplayMode segment_display_mode_;

    bool segment_selectable_;

    double scale_;

    pv::util::Timestamp offset_;
    pv::util::Timestamp ruler_offset_;
    pv::util::Timestamp zero_offset_;
    bool custom_zero_offset_set_;

    bool updating_scroll_;
    bool restoring_state_;
    bool header_was_shrunk_;

    bool sticky_scrolling_;
    bool colored_bg_;
    bool always_zoom_to_fit_;

    pv::util::Timestamp tick_period_;
    pv::util::SIPrefix tick_prefix_;
    unsigned int minor_tick_count_;
    unsigned int tick_precision_;
    util::TimeUnit time_unit_;

    bool show_cursors_;
    shared_ptr<CursorPair> cursors_;

    list< shared_ptr<Flag> > flags_;
    char next_flag_text_;

    vector< shared_ptr<TriggerMarker> > trigger_markers_;

    QWidget* hover_widget_;
    TimeMarker* grabbed_widget_;
    QPoint hover_point_;
    shared_ptr<Signal> signal_under_mouse_cursor_;
    uint16_t snap_distance_;

    unsigned int sticky_events_;
    QTimer lazy_event_handler_;

    // This is true when the defaults couldn't be set due to insufficient info
    bool scroll_needs_defaults_;

    // The v offset to restore. See View::eventFilter()
    int saved_v_offset_;

    // These are used to determine whether the view was altered after acq started
    double scale_at_acq_start_;
    pv::util::Timestamp offset_at_acq_start_;

    // X coordinate of mouse cursor where the user clicked to open a context menu
    uint32_t context_menu_x_pos_;
};

} // namespace trace
} // namespace views
} // namespace pv

#endif // PULSEVIEW_PV_VIEWS_TRACE_VIEW_HPP