decoder_selector: Auto-place the keyboard cursor in the filter.
[pulseview.git] / pv / subwindows / decoder_selector / subwindow.cpp
1 /*
2  * This file is part of the PulseView project.
3  *
4  * Copyright (C) 2018 Soeren Apel <soeren@apelpie.net>
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 <algorithm>
21
22 #include <QApplication>
23 #include <QDebug>
24 #include <QFontMetrics>
25 #include <QInputDialog>
26 #include <QLabel>
27 #include <QLineEdit>
28 #include <QPushButton>
29 #include <QScrollArea>
30 #include <QVBoxLayout>
31
32 #include "pv/session.hpp"
33 #include "pv/subwindows/decoder_selector/subwindow.hpp"
34
35 using std::reverse;
36 using std::shared_ptr;
37
38 namespace pv {
39 namespace subwindows {
40 namespace decoder_selector {
41
42 const QString initial_notice = QApplication::tr("Select a decoder to see its description here.");
43 const int min_width_margin = 75;
44
45
46 bool QCustomSortFilterProxyModel::filterAcceptsRow(int source_row,
47         const QModelIndex& source_parent) const
48 {
49         // Search model recursively
50
51         if (QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent))
52                 return true;
53
54         const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
55
56         for (int i = 0; i < sourceModel()->rowCount(index); i++)
57                 if (filterAcceptsRow(i, index))
58                         return true;
59
60         return false;
61 }
62
63
64 void QCustomTreeView::currentChanged(const QModelIndex& current,
65         const QModelIndex& previous)
66 {
67         QTreeView::currentChanged(current, previous);
68         currentChanged(current);
69 }
70
71
72 SubWindow::SubWindow(Session& session, QWidget* parent) :
73         SubWindowBase(session, parent),
74         splitter_(new QSplitter()),
75         tree_view_(new QCustomTreeView()),
76         info_box_(new QWidget()),
77         info_label_header_(new QLabel()),
78         info_label_body_(new QLabel()),
79         info_label_footer_(new QLabel()),
80         model_(new DecoderCollectionModel()),
81         sort_filter_model_(new QCustomSortFilterProxyModel())
82 {
83         QVBoxLayout* root_layout = new QVBoxLayout(this);
84         root_layout->setContentsMargins(0, 0, 0, 0);
85         root_layout->addWidget(splitter_);
86
87         QWidget* upper_container = new QWidget();
88         QVBoxLayout* upper_layout = new QVBoxLayout(upper_container);
89         upper_layout->setContentsMargins(0, 5, 0, 0);
90         QLineEdit* filter = new QLineEdit();
91         upper_layout->addWidget(filter);
92         upper_layout->addWidget(tree_view_);
93
94         splitter_->setOrientation(Qt::Vertical);
95         splitter_->addWidget(upper_container);
96         splitter_->addWidget(info_box_);
97
98         const QIcon filter_icon(QIcon::fromTheme("search",
99                 QIcon(":/icons/search.svg")));
100         filter->setClearButtonEnabled(true);
101         filter->addAction(filter_icon, QLineEdit::LeadingPosition);
102
103         sort_filter_model_->setSourceModel(model_);
104         sort_filter_model_->setFilterCaseSensitivity(Qt::CaseInsensitive);
105         sort_filter_model_->setFilterKeyColumn(-1);
106
107         tree_view_->setModel(sort_filter_model_);
108         tree_view_->setRootIsDecorated(true);
109         tree_view_->setSortingEnabled(true);
110         tree_view_->sortByColumn(0, Qt::AscendingOrder);
111
112         // Hide the columns that hold the detailed item information
113         tree_view_->hideColumn(2);  // ID
114
115         // Ensure that all decoder tag names are fully visible by default
116         tree_view_->resizeColumnToContents(0);
117
118         tree_view_->setIndentation(10);
119
120         QScrollArea* info_label_body_container = new QScrollArea();
121         info_label_body_container->setWidget(info_label_body_);
122         info_label_body_container->setWidgetResizable(true);
123
124         info_box_->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
125         QVBoxLayout* info_box_layout = new QVBoxLayout(info_box_);
126         info_box_layout->addWidget(info_label_header_);
127         info_box_layout->addWidget(info_label_body_container);
128         info_box_layout->addWidget(info_label_footer_);
129         info_box_layout->setAlignment(Qt::AlignTop);
130         Qt::TextInteractionFlags flags = Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard;
131         info_label_header_->setWordWrap(true);
132         info_label_header_->setTextInteractionFlags(flags);
133         info_label_body_->setWordWrap(true);
134         info_label_body_->setTextInteractionFlags(flags);
135         info_label_body_->setText(initial_notice);
136         info_label_body_->setAlignment(Qt::AlignTop);
137         info_label_footer_->setWordWrap(true);
138         info_label_footer_->setTextInteractionFlags(flags);
139
140         connect(filter, SIGNAL(textChanged(const QString&)),
141                 this, SLOT(on_filter_changed(const QString&)));
142
143         connect(tree_view_, SIGNAL(currentChanged(const QModelIndex&)),
144                 this, SLOT(on_item_changed(const QModelIndex&)));
145         connect(tree_view_, SIGNAL(activated(const QModelIndex&)),
146                 this, SLOT(on_item_activated(const QModelIndex&)));
147
148         connect(this, SIGNAL(new_decoders_selected(vector<const srd_decoder*>)),
149                 &session, SLOT(on_new_decoders_selected(vector<const srd_decoder*>)));
150
151         // Place the keyboard cursor in the filter QLineEdit initially
152         filter->setFocus();
153 }
154
155 bool SubWindow::has_toolbar() const
156 {
157         return true;
158 }
159
160 QToolBar* SubWindow::create_toolbar(QWidget *parent) const
161 {
162         QToolBar* toolbar = new QToolBar(parent);
163
164         return toolbar;
165 }
166
167 int SubWindow::minimum_width() const
168 {
169         QFontMetrics m(info_label_body_->font());
170         const int label_width = m.width(initial_notice);
171
172         return label_width + min_width_margin;
173 }
174
175 vector<const char*> SubWindow::get_decoder_inputs(const srd_decoder* d) const
176 {
177         vector<const char*> ret_val;
178
179         for (GSList* li = d->inputs; li; li = li->next)
180                 ret_val.push_back((const char*)li->data);
181
182         return ret_val;
183 }
184
185 vector<const srd_decoder*> SubWindow::get_decoders_providing(const char* output) const
186 {
187         vector<const srd_decoder*> ret_val;
188
189         for (GSList* li = (GSList*)srd_decoder_list(); li; li = li->next) {
190                 const srd_decoder* d = (srd_decoder*)li->data;
191                 assert(d);
192
193                 if (!d->outputs)
194                         continue;
195
196                 // TODO For now we ignore that d->outputs is actually a list
197                 if (strncmp((char*)(d->outputs->data), output, strlen(output)) == 0)
198                         ret_val.push_back(d);
199         }
200
201         return ret_val;
202 }
203
204 void SubWindow::on_item_changed(const QModelIndex& index)
205 {
206         if (!index.isValid())
207                 return;
208
209         QModelIndex id_index = index.model()->index(index.row(), 2, index.parent());
210         QString decoder_name = index.model()->data(id_index, Qt::DisplayRole).toString();
211
212         if (decoder_name.isEmpty())
213                 return;
214
215         const srd_decoder* d = srd_decoder_get_by_id(decoder_name.toUtf8());
216
217         const QString id = QString::fromUtf8(d->id);
218         const QString longname = QString::fromUtf8(d->longname);
219         const QString desc = QString::fromUtf8(d->desc);
220         const QString doc = QString::fromUtf8(srd_decoder_doc_get(d)).trimmed();
221
222         QString tags;
223         for (GSList* li = (GSList*)d->tags; li; li = li->next) {
224                 QString s = (li == (GSList*)d->tags) ?
225                         tr((char*)li->data) :
226                         QString(tr(", %1")).arg(tr((char*)li->data));
227                 tags.append(s);
228         }
229
230         info_label_header_->setText(QString("<span style='font-size:large'><b>%1 (%2)</b></span><br><i>%3</i>")
231                 .arg(longname, id, desc));
232         info_label_body_->setText(doc);
233         info_label_footer_->setText(tr("<p align='right'>Tags: %1</p>").arg(tags));
234 }
235
236 void SubWindow::on_item_activated(const QModelIndex& index)
237 {
238         if (!index.isValid())
239                 return;
240
241         QModelIndex id_index = index.model()->index(index.row(), 2, index.parent());
242         QString decoder_name = index.model()->data(id_index, Qt::DisplayRole).toString();
243
244         const srd_decoder* chosen_decoder = srd_decoder_get_by_id(decoder_name.toUtf8());
245         if (chosen_decoder == nullptr)
246                 return;
247
248         vector<const srd_decoder*> decoders;
249         decoders.push_back(chosen_decoder);
250
251         // If the decoder only depends on logic inputs, we add it and are done
252         vector<const char*> inputs = get_decoder_inputs(decoders.front());
253         if (inputs.size() == 0) {
254                 qWarning() << "Protocol decoder" << decoder_name << "cannot have 0 inputs!";
255                 return;
256         }
257
258         if (strncmp(inputs.at(0), "logic", 5) == 0) {
259                 new_decoders_selected(decoders);
260                 return;
261         }
262
263         // Check if we can automatically fulfill the stacking requirements
264         while (strncmp(inputs.at(0), "logic", 5) != 0) {
265                 vector<const srd_decoder*> prov_decoders = get_decoders_providing(inputs.at(0));
266
267                 if (prov_decoders.size() == 0) {
268                         // Emit warning and add the stack that we could gather so far
269                         qWarning() << "Protocol decoder" << QString::fromUtf8(decoders.back()->id) \
270                                 << "has input that no other decoder provides:" << QString::fromUtf8(inputs.at(0));
271                         break;
272                 }
273
274                 if (prov_decoders.size() == 1) {
275                         decoders.push_back(prov_decoders.front());
276                 } else {
277                         // Let user decide which one to use
278                         QString caption = QString(tr("Protocol decoder <b>%1</b> requires input type <b>%2</b> " \
279                                 "which several decoders provide.<br>Choose which one to use:<br>"))
280                                         .arg(QString::fromUtf8(decoders.back()->id), QString::fromUtf8(inputs.at(0)));
281
282                         QStringList items;
283                         for (const srd_decoder* d : prov_decoders)
284                                 items << QString::fromUtf8(d->id) + " (" + QString::fromUtf8(d->longname) + ")";
285                         bool ok_clicked;
286                         QString item = QInputDialog::getItem(this, tr("Choose Decoder"),
287                                 tr(caption.toUtf8()), items, 0, false, &ok_clicked);
288
289                         if ((!ok_clicked) || (item.isEmpty()))
290                                 return;
291
292                         QString d = item.section(' ', 0, 0);
293                         decoders.push_back(srd_decoder_get_by_id(d.toUtf8()));
294                 }
295
296                 inputs = get_decoder_inputs(decoders.back());
297         }
298
299         // Reverse decoder list and add the stack
300         reverse(decoders.begin(), decoders.end());
301         new_decoders_selected(decoders);
302 }
303
304 void SubWindow::on_filter_changed(const QString& text)
305 {
306         sort_filter_model_->setFilterFixedString(text);
307 }
308
309 } // namespace decoder_selector
310 } // namespace subwindows
311 } // namespace pv