packet_list.h

Go to the documentation of this file.

 
#ifndef PACKET_LIST_H
#define PACKET_LIST_H
 
#include "data_source_tab.h"
#include <ui/qt/models/packet_list_model.h>
#include <ui/qt/models/packet_list_proxy_model.h>
#include "proto_tree.h"
#include "protocol_preferences_menu.h"
#include <ui/qt/models/related_packet_delegate.h>
#include <ui/qt/models/multi_color_packet_delegate.h>
#include <ui/qt/models/tag_column_delegate.h>
#include <ui/qt/utils/field_information.h>
#include <ui/qt/widgets/pinned_column_view.h>
#include <ui/qt/widgets/pinned_row_view.h>
#include <ui/qt/models/pinned_rows_model.h>
#include "capture_event.h"
 
#include <QElapsedTimer>
#include <QMenu>
#include <QTime>
#include <QTreeView>
#include <QPainter>
 
class PacketListHeader;
class OverlayScrollBar;
class ProfileSwitcher;
 
class QAction;
class QTimerEvent;
 
//
// XXX - Wireshark supports up to 2^32-1 packets in a capture, but
// row numbers in a QAbstractItemModel are ints, not unsigned ints,
// so we can only have 2^31-1 rows on ILP32, LP64, and LLP64 platforms.
// Does that mean we're permanently stuck at a maximum of 2^31-1 packets
// per capture?
//

class PacketList : public QTreeView
{
    Q_OBJECT
public:
    explicit PacketList(QWidget *parent = 0);

    ~PacketList();

    enum SummaryCopyType {
        CopyAsText,
        CopyAsCSV,
        CopyAsYAML,
        CopyAsHTML
    };
    Q_ENUM(SummaryCopyType)
 
    
    virtual void scrollTo(const QModelIndex &index, QAbstractItemView::ScrollHint hint = EnsureVisible) override;

    QMenu *conversationMenu() { return &conv_menu_; }

    QMenu *colorizeMenu() { return &colorize_menu_; }

    void setProtoTree(ProtoTree *proto_tree);

    bool freeze(bool keep_current_frame = false);

    bool thaw(bool restore_selection = false);

    bool isFrozen() const { return model() == nullptr; }

    void clear();

    void writeRecent(FILE *rf);

    bool contextMenuActive();

    QString getFilterFromRowAndColumn(QModelIndex idx);

    QString getFilterFromFdataAndColumn(frame_data *fdata, int column);

    void resetColorized();

    QString getPacketComment(unsigned c_number);

    void addPacketComment(QString new_comment);

    void setPacketComment(unsigned c_number, QString new_comment);

    QString allPacketComments();

    void deleteCommentsFromPackets();

    void deleteAllPacketComments();

    void setVerticalAutoScroll(bool enabled = true);

    void setCaptureInProgress(bool in_progress = false, bool auto_scroll = true) { capture_in_progress_ = in_progress; tail_at_end_ = in_progress && auto_scroll; }

    void captureFileReadFinished(CaptureEvent::Context context);

    void captureFileReloadPending() { reload_pending_ = true; }

    void setColumnDelegate();

    void setColumnVisibility();

    void resetColumns();

    bool haveNextHistory(bool update_cur = false);

    bool havePreviousHistory(bool update_cur = false);

    void setProfileSwitcher(ProfileSwitcher *profile_switcher);

    frame_data * getFDataForRow(int row) const;

    bool uniqueSelectActive();

    bool multiSelectActive();

    QList<int> selectedRows(bool useFrameNum = false);

    QList<frame_data *> selectedFrames(bool fall_back_to_current = true) const;

    int selectedFrameCount(int limit = 0) const;

    QString createSummaryText(int frame_num, SummaryCopyType type);

    QString createHeaderSummaryText(SummaryCopyType type);

    QStringList createHeaderPartsForAligned();

    QList<int> createAlignmentPartsForAligned();

    QList<int> createSizePartsForAligned(bool useHeader, QStringList hdr_parts, QList<int> frame_nums);

    QString createHeaderSummaryForAligned(QStringList hdr_parts, QList<int> align_parts, QList<int> size_parts);

    QString createSummaryForAligned(int frame_num, QList<int> align_parts, QList<int> size_parts);

    QString createDefaultStyleForHtml();

    QString createOpeningTagForHtml();

    QString createHeaderSummaryForHtml();

    QString createSummaryForHtml(int frame_num);

    QString createClosingTagForHtml();

    void resizeAllColumns(bool onlyTimeFormatted = false);

    void pinSelectedRows();

    void unpinSelectedRows();
 
    // Unpins every currently pinned packet's row.
    void unpinAllRows();

    enum PinAction {
        NoPinAction,      
        PinRows,          
        PinRowsOverLimit, 
        UnpinRows,        
    };

    PinAction selectedRowsPinAction() const;

    void togglePinSelectedRows();

    void updatePinActions(QAction *pin_selected, QAction *unpin_all) const;

    int pinnedRowHeight() const;

    void setPinnedColumnBoundary(int column_count);

    int pinnedColumnBoundary() const { return pinned_column_boundary_; }

    static bool isColumnFrozen(int column, int boundary) { return column < boundary; }

    void setPinnedRowViews(PinnedRowView *row_view, PinnedRowView *corner_view);

    void selectRowFromOverlay(int row, int column, Qt::MouseButtons buttons,
                               Qt::KeyboardModifiers modifiers = Qt::NoModifier);

    void startCellDragFromOverlay(int row, int column);

    void startCellDragForSourceIndex(const QModelIndex &source_index);

    void toggleFrameMarkFromClick(const QModelIndex &source_index);

    void showContextMenuForRow(int row, const QPoint &global_pos);

    void showContextMenuForSourceIndex(const QModelIndex &source_index, const QPoint &global_pos,
                                       bool from_pinned_row_strip = false);

    QPoint frozenHeaderPosToReal(const QPoint &frozen_pos) const;

    void forwardHeaderContextMenu(QContextMenuEvent *event, const QPoint &header_pos);

    void forwardHeaderMousePress(QMouseEvent *event, const QPoint &header_pos);
 
    // Forwards a header mouse move (used for resize dragging).
    void forwardHeaderMouseMove(QMouseEvent *event, const QPoint &header_pos);
 
    // Forwards a header mouse release (used for resize dragging).
    void forwardHeaderMouseRelease(QMouseEvent *event, const QPoint &header_pos);

    void sortByColumnFromOverlay(int column);

    void forwardWheelEvent(QWheelEvent *event);

    void setHoveredRowFromOverlay(int row);

    void setHoveredFrameNum(int frame_num);

    int hoveredFrameNum() const { return hovered_frame_num_; }

    void paintHoveredRow(QPainter *painter, const QTreeView *view,
                         const QStyleOptionViewItem &option, const QModelIndex &index) const;
 
protected:
    virtual void changeEvent(QEvent *event) override;

    void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) override;

    virtual void contextMenuEvent(QContextMenuEvent *event) override;

    void timerEvent(QTimerEvent *event) override;

    void paintEvent(QPaintEvent *event) override;

    virtual void mousePressEvent (QMouseEvent *event) override;

    virtual void mouseReleaseEvent (QMouseEvent *event) override;

    virtual void mouseMoveEvent (QMouseEvent *event) override;

    virtual void leaveEvent(QEvent *event) override;

    virtual void resizeEvent(QResizeEvent *event) override;

    virtual void keyPressEvent(QKeyEvent *event) override;

    virtual void keyReleaseEvent(QKeyEvent *event) override;

    virtual void focusInEvent(QFocusEvent *event) override;

    virtual void focusOutEvent(QFocusEvent *event) override;
 
protected slots:
    void rowsInserted(const QModelIndex &parent, int start, int end) override;

    virtual void drawRow(QPainter *painter, const QStyleOptionViewItem &option,
        const QModelIndex &index) const override;
 
private:
    QModelIndexList selectedSourceIndexes() const;

    void installSelectionModel();

    void reconcilePinnedSelection();

    void syncPinnedSelection(bool to_pinned);

    PacketListModel *packet_list_model_;

    PacketListProxyModel *packet_list_proxy_model_;

    PacketListHeader * packet_list_header_;

    ProtoTree *proto_tree_;

    capture_file *cap_file_;

    QMenu conv_menu_;

    QMenu colorize_menu_;

    void startCellDrag(frame_data *fdata, int column, const QString &cell_text);

    int ctx_column_;

    QByteArray column_state_;

    OverlayScrollBar *overlay_sb_;

    int overlay_timer_id_;

    int turbo_timer_id_;

    Qt::Key turbo_key_;

    Qt::Key held_key_;

    QElapsedTimer key_hold_elapsed_;

    bool create_near_overlay_;

    bool create_far_overlay_;

    QVector<QRgb> overlay_colors_;

    bool changing_profile_;

    QModelIndex mouse_pressed_at_;

    RelatedPacketDelegate related_packet_delegate_;

    MultiColorPacketDelegate multi_color_delegate_;
    TagColumnDelegate tag_column_delegate_;

    QAction *show_hide_separator_;

    QList<QAction *>show_hide_actions_;

    bool capture_in_progress_;

    bool tail_at_end_;

    bool columns_changed_;

    bool set_column_visibility_;

    bool set_style_sheet_;

    QModelIndex frozen_current_row_;

    QModelIndexList frozen_selected_rows_;

    PinnedRowsModel *pinned_rows_model_;

    QItemSelectionModel *pinned_selection_model_;

    bool syncing_selection_;
 
    // Number of leftmost columns currently frozen/pinned, or 0.
    int pinned_column_boundary_;
    // The file is being closed and reopened to reload it, so keep
    // pinned_rows_model_'s saved pins; see setCaptureFile().
    bool reload_pending_;
 
    // Overlay view showing the frozen leftmost columns for all rows.
    PinnedColumnView *pinned_column_view_;

    QSize pinned_column_view_size_;
    bool header_drag_active_ = false;
    void updateFrozenOverlayMask();
 
    // Overlay view showing the pinned row's non-frozen columns.
    PinnedRowView *pinned_row_view_;
 
    // Overlay view showing the pinned row's frozen columns (the "corner").
    PinnedRowView *pinned_row_corner_view_;
 
    // Cached selection stylesheet for the overlay views when this window is active.
    QString overlay_active_flat_style_;
 
    // Cached selection stylesheet for the overlay views when this window is inactive.
    QString overlay_inactive_flat_style_;

    int hovered_frame_num_;

    QVector<int> selection_history_;

    int cur_history_;

    bool in_history_;

    GPtrArray *finfo_array;

    ProfileSwitcher *profile_switcher_;

    void updateHistory(int frame_num);

    void setFrameReftime(bool set, frame_data *fdata);

    void setRecentColumnWidth(int column);

    void drawCurrentPacket(bool scroll = true);

    void applyRecentColumnWidths();

    QList<QTreeView *> pinnedOverlayViews() const;

    void repaintPinnedOverlays();

    void mirrorSectionWidthToOverlays(int column, int width);

    void applyOverlayActiveState();

    bool selectionIsActive() const { return hasFocus() && isActiveWindow(); }

    void applicationFocusChanged(QWidget *old, QWidget *now);

    void scrollViewChanged(bool at_end);

    QString joinSummaryRow(QStringList col_parts, int row, SummaryCopyType type);
 
signals:
    void pinnedRowsChanged();

    void packetDissectionChanged();

    void pinnedRowsCornerWidthChanged(int corner_width, bool have_pinned_rows);

    void columnHiddenChanged(int column, bool hidden);

    void pinnedColumnBoundaryChanged(int column_count);

    void showColumnPreferences(QString pane_name);

    void editColumn(int column);

    void packetListScrolled(bool at_end);

    void showProtocolPreferences(const QString module_name);

    void editProtocolPreference(pref_t *pref, module_t *module);

    void framesSelected(QList<int> frames);

    void fieldSelected(FieldInformation *finfo);
 
public slots:
    void setCaptureFile(capture_file *cf);

    void setMonospaceFont(const QFont &mono_font);

    void setRegularFont(const QFont &regular_font);

    void goNextPacket();

    void goPreviousPacket();

    void goFirstPacket();

    void goLastPacket();

    void goToPacket(int packet, int hf_id = -1);

    void goNextHistoryPacket();

    void goPreviousHistoryPacket();

    void markFrame();

    void markAllDisplayedFrames(bool set);

    void ignoreFrame();

    void ignoreAllDisplayedFrames(bool set);

    void setTimeReference();

    void unsetAllTimeReferences();

    void applyTimeShift();

    void recolorPackets();

    void redrawVisiblePackets();

    void redrawVisiblePacketsDontSelectCurrent();

    void colorsChanged();

    void columnsChanged();

    void fieldsChanged(capture_file *cf);

    void preferencesChanged();

    void freezePacketList(bool changing_profile);
 
private slots:
    void columnVisibilityTriggered();

    void sectionResized(int col, int, int new_width);

    void sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex);

    void copySummary();

    void vScrollBarActionTriggered(int);

    void drawFarOverlay();

    void drawNearOverlay();

    void updatePackets(bool redraw);

    void ctxDecodeAsDialog();

    void updatePinnedRowVisibility();

    void pinnedSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected);

    void pinnedCurrentChanged(const QModelIndex &current);

    void layoutPinnedOverlays();
};
 
#endif // PACKET_LIST_H