pv/views/tabular_decoder/model.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2020 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 <QApplication>
  21 #include <QDebug>
  22 #include <QString>
  23
  24 #include "pv/views/tabular_decoder/view.hpp"
  25
  26 #include "view.hpp"
  27
  28 #include "pv/util.hpp"
  29 #include "pv/globalsettings.hpp"
  30
  31 using std::make_shared;
  32
  33 using pv::util::Timestamp;
  34 using pv::util::format_time_si;
  35 using pv::util::format_time_minutes;
  36 using pv::util::SIPrefix;
  37
  38 namespace pv {
  39 namespace views {
  40 namespace tabular_decoder {
  41
  42 AnnotationCollectionModel::AnnotationCollectionModel(QObject* parent) :
  43         QAbstractTableModel(parent),
  44         all_annotations_(nullptr),
  45         dataset_(nullptr),
  46         signal_(nullptr),
  47         first_hidden_column_(0),
  48         prev_segment_(0),
  49         prev_last_row_(0),
  50         had_highlight_before_(false),
  51         hide_hidden_(false)
  52 {
  53         // Note: when adding entries, consider ViewVisibleFilterProxyModel::filterAcceptsRow()
  54
  55         uint8_t i = 0;
  56         header_data_.emplace_back(tr("Sample"));    i++; // Column #0
  57         header_data_.emplace_back(tr("Time"));      i++; // Column #1
  58         header_data_.emplace_back(tr("Decoder"));   i++; // Column #2
  59         header_data_.emplace_back(tr("Ann Row"));   i++; // Column #3
  60         header_data_.emplace_back(tr("Ann Class")); i++; // Column #4
  61         header_data_.emplace_back(tr("Value"));     i++; // Column #5
  62
  63         first_hidden_column_ = i;
  64         header_data_.emplace_back("End Sample");         // Column #6, hidden
  65 }
  66
  67 int AnnotationCollectionModel::get_hierarchy_level(const Annotation* ann) const
  68 {
  69         int level = 0;
  70
  71         const unsigned int ann_stack_level = ann->row_data()->row()->decoder()->get_stack_level();
  72         level = (signal_->decoder_stack().size() - 1 - ann_stack_level);
  73
  74         return level;
  75 }
  76
  77 QVariant AnnotationCollectionModel::data_from_ann(const Annotation* ann, int index) const
  78 {
  79         switch (index) {
  80         case 0: return QVariant((qulonglong)ann->start_sample());  // Column #0, Start Sample
  81         case 1: {                                                  // Column #1, Start Time
  82                         Timestamp t = ann->start_sample() / signal_->get_samplerate();
  83                         QString unit = signal_->get_samplerate() ? tr("s") : tr("sa");
  84                         QString s;
  85                         if ((t < 60) || (signal_->get_samplerate() == 0))  // i.e. if unit is sa
  86                                 s = format_time_si(t, SIPrefix::unspecified, 3, unit, false);
  87                         else
  88                                 s = format_time_minutes(t, 3, false);
  89                         return QVariant(s);
  90                 }
  91         case 2: return QVariant(ann->row()->decoder()->name());    // Column #2, Decoder
  92         case 3: return QVariant(ann->row()->description());        // Column #3, Ann Row
  93         case 4: return QVariant(ann->ann_class_description());     // Column #4, Ann Class
  94         case 5: return QVariant(ann->longest_annotation());        // Column #5, Value
  95         case 6: return QVariant((qulonglong)ann->end_sample());    // Column #6, End Sample
  96         default: return QVariant();
  97         }
  98 }
  99
 100 QVariant AnnotationCollectionModel::data(const QModelIndex& index, int role) const
 101 {
 102         if (!signal_ || !index.isValid() || !index.internalPointer())
 103                 return QVariant();
 104
 105         const Annotation* ann =
 106                 static_cast<const Annotation*>(index.internalPointer());
 107
 108         if ((role == Qt::DisplayRole) || (role == Qt::ToolTipRole))
 109                 return data_from_ann(ann, index.column());
 110
 111         if (role == Qt::ForegroundRole) {
 112                 if (index.column() >= get_hierarchy_level(ann)) {
 113                         // Invert the text color if this cell is highlighted
 114                         const bool must_highlight = (highlight_sample_num_ > 0) &&
 115                                 ((int64_t)ann->start_sample() <= highlight_sample_num_) &&
 116                                 ((int64_t)ann->end_sample() >= highlight_sample_num_);
 117
 118                         if (must_highlight) {
 119                                 if (GlobalSettings::current_theme_is_dark())
 120                                         return QApplication::palette().brush(QPalette::Window);
 121                                 else
 122                                         return QApplication::palette().brush(QPalette::WindowText);
 123                         }
 124                 }
 125
 126                 return QApplication::palette().brush(QPalette::WindowText);
 127         }
 128
 129         if (role == Qt::BackgroundRole) {
 130                 // Only use custom cell background color if column index reached the hierarchy level
 131                 if (index.column() >= get_hierarchy_level(ann)) {
 132
 133                         QColor color;
 134                         const bool must_highlight = (highlight_sample_num_ > 0) &&
 135                                 ((int64_t)ann->start_sample() <= highlight_sample_num_) &&
 136                                 ((int64_t)ann->end_sample() >= highlight_sample_num_);
 137
 138                         if (must_highlight)
 139                                 color = ann->color();
 140                         else
 141                                 color = GlobalSettings::current_theme_is_dark() ?
 142                                         ann->dark_color() : ann->bright_color();
 143
 144                         return QBrush(color);
 145                 }
 146         }
 147
 148         return QVariant();
 149 }
 150
 151 Qt::ItemFlags AnnotationCollectionModel::flags(const QModelIndex& index) const
 152 {
 153         if (!index.isValid())
 154                 return Qt::NoItemFlags;
 155
 156         return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemNeverHasChildren;
 157 }
 158
 159 uint8_t AnnotationCollectionModel::first_hidden_column() const
 160 {
 161         return first_hidden_column_;
 162 }
 163
 164 QVariant AnnotationCollectionModel::headerData(int section, Qt::Orientation orientation,
 165         int role) const
 166 {
 167         if ((section < 0) || (section >= (int)header_data_.size()))
 168                 return QVariant();
 169
 170         if ((orientation == Qt::Horizontal) && (role == Qt::DisplayRole))
 171                 return header_data_[section];
 172
 173         return QVariant();
 174 }
 175
 176 QModelIndex AnnotationCollectionModel::index(int row, int column,
 177         const QModelIndex& parent_idx) const
 178 {
 179         (void)parent_idx;
 180         assert(column >= 0);
 181
 182         if (!dataset_ || (row < 0))
 183                 return QModelIndex();
 184
 185         QModelIndex idx;
 186
 187         if ((size_t)row < dataset_->size())
 188                 idx = createIndex(row, column, (void*)dataset_->at(row));
 189
 190         return idx;
 191 }
 192
 193 QModelIndex AnnotationCollectionModel::parent(const QModelIndex& index) const
 194 {
 195         (void)index;
 196
 197         return QModelIndex();
 198 }
 199
 200 int AnnotationCollectionModel::rowCount(const QModelIndex& parent_idx) const
 201 {
 202         (void)parent_idx;
 203
 204         if (!dataset_)
 205                 return 0;
 206
 207         return dataset_->size();
 208 }
 209
 210 int AnnotationCollectionModel::columnCount(const QModelIndex& parent_idx) const
 211 {
 212         (void)parent_idx;
 213
 214         return header_data_.size();
 215 }
 216
 217 void AnnotationCollectionModel::set_signal_and_segment(data::DecodeSignal* signal, uint32_t current_segment)
 218 {
 219         layoutAboutToBeChanged();
 220
 221         if (!signal) {
 222                 all_annotations_ = nullptr;
 223                 dataset_ = nullptr;
 224                 signal_ = nullptr;
 225
 226                 dataChanged(QModelIndex(), QModelIndex());
 227                 layoutChanged();
 228                 return;
 229         }
 230
 231         for (const shared_ptr<Decoder>& dec : signal_->decoder_stack())
 232                 disconnect(dec.get(), nullptr, this, SLOT(on_annotation_visibility_changed()));
 233
 234         all_annotations_ = signal->get_all_annotations_by_segment(current_segment);
 235         signal_ = signal;
 236
 237         for (const shared_ptr<Decoder>& dec : signal_->decoder_stack())
 238                 connect(dec.get(), SIGNAL(annotation_visibility_changed()),
 239                         this, SLOT(on_annotation_visibility_changed()));
 240
 241         if (hide_hidden_) {
 242                 update_annotations_without_hidden();
 243                 dataset_ = &all_annotations_without_hidden_;
 244         } else
 245                 dataset_ = all_annotations_;
 246
 247         if (!dataset_ || dataset_->empty()) {
 248                 prev_segment_ = current_segment;
 249                 return;
 250         }
 251
 252         const size_t new_row_count = dataset_->size() - 1;
 253
 254         // Force the view associated with this model to update when the segment changes
 255         if (prev_segment_ != current_segment) {
 256                 dataChanged(index(0, 0), index(new_row_count, 0));
 257                 layoutChanged();
 258         } else {
 259                 // Force the view associated with this model to update when we have more annotations
 260                 if (prev_last_row_ < new_row_count) {
 261                         dataChanged(index(prev_last_row_, 0), index(new_row_count, 0));
 262                         layoutChanged();
 263                 }
 264         }
 265
 266         prev_segment_ = current_segment;
 267         prev_last_row_ = new_row_count;
 268 }
 269
 270 void AnnotationCollectionModel::set_hide_hidden(bool hide_hidden)
 271 {
 272         layoutAboutToBeChanged();
 273
 274         hide_hidden_ = hide_hidden;
 275
 276         if (hide_hidden_) {
 277                 dataset_ = &all_annotations_without_hidden_;
 278                 update_annotations_without_hidden();
 279         } else {
 280                 dataset_ = all_annotations_;
 281                 all_annotations_without_hidden_.clear();  // To conserve memory
 282         }
 283
 284         if (dataset_)
 285                 dataChanged(index(0, 0), index(dataset_->size() - 1, 0));
 286         else
 287                 dataChanged(QModelIndex(), QModelIndex());
 288
 289         layoutChanged();
 290 }
 291
 292 void AnnotationCollectionModel::update_annotations_without_hidden()
 293 {
 294         uint64_t count = 0;
 295
 296         if (!all_annotations_ || all_annotations_->empty()) {
 297                 all_annotations_without_hidden_.clear();
 298                 return;
 299         }
 300
 301         for (const Annotation* ann : *all_annotations_) {
 302                 if (!ann->visible())
 303                         continue;
 304
 305                 if (all_annotations_without_hidden_.size() < (count + 100))
 306                         all_annotations_without_hidden_.resize(count + 100);
 307
 308                 all_annotations_without_hidden_[count++] = ann;
 309         }
 310
 311         all_annotations_without_hidden_.resize(count);
 312 }
 313
 314 QModelIndex AnnotationCollectionModel::update_highlighted_rows(QModelIndex first,
 315         QModelIndex last, int64_t sample_num)
 316 {
 317         bool has_highlight = false;
 318         QModelIndex result;
 319
 320         highlight_sample_num_ = sample_num;
 321
 322         if (!dataset_ || dataset_->empty())
 323                 return result;
 324
 325         if (sample_num >= 0) {
 326                 last = last.sibling(last.row() + 1, 0);
 327
 328                 // Check if there are any annotations visible in the table view that
 329                 // we would need to highlight - only then do we do so
 330                 QModelIndex index = first;
 331                 do {
 332                         const Annotation* ann = static_cast<const Annotation*>(index.internalPointer());
 333                         if (!ann)  // Can happen if the table is being modified at this exact time
 334                                 return result;
 335
 336                         if (((int64_t)ann->start_sample() <= sample_num) &&
 337                                 ((int64_t)ann->end_sample() >= sample_num)) {
 338                                 result = index;
 339                                 has_highlight = true;
 340                                 break;
 341                         }
 342
 343                         index = index.sibling(index.row() + 1, 0);
 344                 } while (index != last);
 345         }
 346
 347         if (has_highlight || had_highlight_before_)
 348                 dataChanged(first, last);
 349
 350         had_highlight_before_ = has_highlight;
 351
 352         return result;
 353 }
 354
 355 void AnnotationCollectionModel::on_annotation_visibility_changed()
 356 {
 357         if (!hide_hidden_)
 358                 return;
 359
 360         layoutAboutToBeChanged();
 361
 362         update_annotations_without_hidden();
 363
 364         if (dataset_)
 365                 dataChanged(index(0, 0), index(dataset_->size() - 1, 0));
 366         else
 367                 dataChanged(QModelIndex(), QModelIndex());
 368
 369         layoutChanged();
 370 }
 371
 372 } // namespace tabular_decoder
 373 } // namespace views
 374 } // namespace pv