TraceView: Fix variable name
[pulseview.git] / pv / view / tracegroup.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2013 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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <extdef.h>
21 #include <assert.h>
22
23 #include <algorithm>
24
25 #include <QMenu>
26 #include <QPainter>
27
28 #include "tracegroup.hpp"
29
30 using std::pair;
31 using std::shared_ptr;
32 using std::vector;
33
34 namespace pv {
35 namespace views {
36 namespace TraceView {
37
38 const int TraceGroup::Padding = 8;
39 const int TraceGroup::Width = 12;
40 const int TraceGroup::LineThickness = 5;
41 const QColor TraceGroup::LineColour(QColor(0x55, 0x57, 0x53));
42
43 TraceGroup::~TraceGroup()
44 {
45         owner_ = nullptr;
46         clear_child_items();
47 }
48
49 bool TraceGroup::enabled() const
50 {
51         return std::any_of(child_items().begin(), child_items().end(),
52                 [](const shared_ptr<ViewItem> &r) { return r->enabled(); });
53 }
54
55 pv::Session& TraceGroup::session()
56 {
57         assert(owner_);
58         return owner_->session();
59 }
60
61 const pv::Session& TraceGroup::session() const
62 {
63         assert(owner_);
64         return owner_->session();
65 }
66
67 View* TraceGroup::view()
68 {
69         assert(owner_);
70         return owner_->view();
71 }
72
73 const View* TraceGroup::view() const
74 {
75         assert(owner_);
76         return owner_->view();
77 }
78
79 pair<int, int> TraceGroup::v_extents() const
80 {
81         return TraceTreeItemOwner::v_extents();
82 }
83
84 void TraceGroup::paint_label(QPainter &p, const QRect &rect, bool hover)
85 {
86         const QRectF r = label_rect(rect).adjusted(
87                 LineThickness / 2, LineThickness / 2,
88                 -LineThickness / 2, -LineThickness / 2);
89
90         // Paint the label
91         const QPointF points[] = {
92                 r.topRight(),
93                 r.topLeft(),
94                 r.bottomLeft(),
95                 r.bottomRight()
96         };
97
98         if (selected()) {
99                 const QPen pen(highlight_pen());
100                 p.setPen(QPen(pen.brush(), pen.width() + LineThickness,
101                         Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin));
102                 p.setBrush(Qt::transparent);
103                 p.drawPolyline(points, countof(points));
104         }
105
106         p.setPen(QPen(QBrush(LineColour.darker()), LineThickness,
107                 Qt::SolidLine, Qt::SquareCap, Qt::RoundJoin));
108         p.drawPolyline(points, countof(points));
109         p.setPen(QPen(QBrush(hover ? LineColour.lighter() : LineColour),
110                 LineThickness - 2, Qt::SolidLine, Qt::SquareCap,
111                 Qt::RoundJoin));
112         p.drawPolyline(points, countof(points));
113 }
114
115 QRectF TraceGroup::label_rect(const QRectF &rect) const
116 {
117         QRectF child_rect;
118         for (const shared_ptr<ViewItem> r : child_items())
119                 if (r && r->enabled())
120                         child_rect = child_rect.united(r->label_rect(rect));
121
122         return QRectF(child_rect.x() - Width - Padding, child_rect.y(),
123                 Width, child_rect.height());
124 }
125
126 bool TraceGroup::pt_in_label_rect(int left, int right, const QPoint &point)
127 {
128         (void)left;
129         (void)right;
130         (void)point;
131
132         return false;
133 }
134
135 QMenu* TraceGroup::create_context_menu(QWidget *parent)
136 {
137         QMenu *const menu = new QMenu(parent);
138
139         QAction *const ungroup = new QAction(tr("Ungroup"), this);
140         ungroup->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_U));
141         connect(ungroup, SIGNAL(triggered()), this, SLOT(on_ungroup()));
142         menu->addAction(ungroup);
143
144         return menu;
145 }
146
147 pv::widgets::Popup* TraceGroup::create_popup(QWidget *parent)
148 {
149         (void)parent;
150         return nullptr;
151 }
152
153 int TraceGroup::owner_visual_v_offset() const
154 {
155         return owner_ ? visual_v_offset() + owner_->owner_visual_v_offset() : 0;
156 }
157
158 void TraceGroup::restack_items()
159 {
160         vector<shared_ptr<TraceTreeItem>> items(trace_tree_child_items());
161
162         // Sort by the centre line of the extents
163         stable_sort(items.begin(), items.end(),
164                 [](const shared_ptr<TraceTreeItem> &a, const shared_ptr<TraceTreeItem> &b) {
165                         const auto aext = a->v_extents();
166                         const auto bext = b->v_extents();
167                         return a->layout_v_offset() +
168                                         (aext.first + aext.second) / 2 <
169                                 b->layout_v_offset() +
170                                         (bext.first + bext.second) / 2;
171                 });
172
173         int total_offset = 0;
174         for (shared_ptr<TraceTreeItem> r : items) {
175                 const pair<int, int> extents = r->v_extents();
176                 if (extents.first == 0 && extents.second == 0)
177                         continue;
178
179                 // We position disabled traces, so that they are close to the
180                 // animation target positon should they be re-enabled
181                 if (r->enabled())
182                         total_offset += -extents.first;
183
184                 if (!r->dragging())
185                         r->set_layout_v_offset(total_offset);
186
187                 if (r->enabled())
188                         total_offset += extents.second;
189         }
190 }
191
192 unsigned int TraceGroup::depth() const
193 {
194         return owner_ ? owner_->depth() + 1 : 0;
195 }
196
197 void TraceGroup::ungroup()
198 {
199         const vector<shared_ptr<TraceTreeItem>> items(trace_tree_child_items());
200         clear_child_items();
201
202         for (shared_ptr<TraceTreeItem> r : items)
203                 owner_->add_child_item(r);
204
205         owner_->remove_child_item(shared_from_this());
206 }
207
208 void TraceGroup::on_ungroup()
209 {
210         ungroup();
211 }
212
213 void TraceGroup::row_item_appearance_changed(bool label, bool content)
214 {
215         if (owner_)
216                 owner_->row_item_appearance_changed(label, content);
217 }
218
219 void TraceGroup::extents_changed(bool horz, bool vert)
220 {
221         if (owner_)
222                 owner_->extents_changed(horz, vert);
223 }
224
225 } // namespace TraceView
226 } // namespace views
227 } // namespace pv