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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#ifndef PULSEVIEW_PV_VIEW_VIEW_HPP
#define PULSEVIEW_PV_VIEW_VIEW_HPP

#include <stdint.h>

#include <list>
#include <memory>
#include <set>
#include <unordered_map>
#include <vector>

#include <QAbstractScrollArea>
#include <QSizeF>
#include <QTimer>

#include <pv/data/signaldata.hpp>
#include <pv/util.hpp>

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

namespace sigrok {
class ChannelGroup;
}

namespace pv {

class Session;

namespace view {

class CursorHeader;
class Header;
class Ruler;
class Trace;
class Viewport;
class TriggerMarker;

class View : public QAbstractScrollArea, public TraceTreeItemOwner {
    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 MaxViewAutoUpdateRate;

    static const int ScaleUnits[3];

public:
    explicit View(Session &session, QWidget *parent = 0);

    Session& session();
    const Session& session() const;

    virtual pv::view::View* view();

    virtual const pv::view::View* view() const;

    Viewport* viewport();

    const Viewport* viewport() const;

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

    double scale() const;

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

    int owner_visual_v_offset() const;

    void set_v_offset(int offset);

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

    unsigned int tick_precision() const;

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

    util::TimeUnit time_unit() const;

    unsigned int depth() const;

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

    void zoom_fit(bool gui_state);

    void zoom_one_to_one();

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

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

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

    void enable_sticky_scrolling(bool state);

    void enable_coloured_bg(bool state);

    bool cursors_shown() const;

    void show_cursors(bool show = true);

    void centre_cursors();

    std::shared_ptr<CursorPair> cursors() const;

    void add_flag(const pv::util::Timestamp& time);

    void remove_flag(std::shared_ptr<Flag> flag);

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

    const QPoint& hover_point() const;

    void update_viewport();

    void restack_all_trace_tree_items();

Q_SIGNALS:
    void hover_point_changed();

    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();

public Q_SLOTS:
    void trigger_event(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 update_scroll();

    void update_layout();

    void paint_label(QPainter &p, const QRect &rect, bool hover);

    QRectF label_rect(const QRectF &rect);

    TraceTreeItemOwner* find_prevalent_trace_group(
        const std::shared_ptr<sigrok::ChannelGroup> &group,
        const std::unordered_map<std::shared_ptr<sigrok::Channel>,
            std::shared_ptr<Signal> > &signal_map);

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

    void determine_time_unit();

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

    bool viewportEvent(QEvent *e);

    void resizeEvent(QResizeEvent *e);

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 h_scroll_value_changed(int value);
    void v_scroll_value_changed();

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

    void perform_delayed_view_update();

    void process_sticky_events();

    void on_hover_point_changed();

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

    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);

private:
    Session &session_;

    Viewport *viewport_;
    Ruler *ruler_;
    Header *header_;

    double scale_;

    pv::util::Timestamp offset_;

    bool updating_scroll_;
    bool sticky_scrolling_;
    bool always_zoom_to_fit_;
    QTimer delayed_view_updater_;

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

    bool show_cursors_;
    std::shared_ptr<CursorPair> cursors_;

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

    std::vector< std::shared_ptr<TriggerMarker> > trigger_markers_;

    QPoint hover_point_;

    unsigned int sticky_events_;
    QTimer lazy_event_handler_;
};

} // namespace view
} // namespace pv

#endif // PULSEVIEW_PV_VIEW_VIEW_HPP