pv/views/decoder_output/QHexView.cpp

   1 /*
   2  * This file is part of the PulseView project.
   3  *
   4  * Copyright (C) 2015 Victor Anjin <virinext@gmail.com>
   5  * Copyright (C) 2019 Soeren Apel <soeren@apelpie.net>
   6  *
   7  * The MIT License (MIT)
   8  *
   9  * Copyright (c) 2015
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in all
  19  * copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #include <QApplication>
  31 #include <QClipboard>
  32 #include <QFont>
  33 #include <QKeyEvent>
  34 #include <QScrollBar>
  35 #include <QSize>
  36 #include <QPainter>
  37 #include <QPaintEvent>
  38
  39 #include "QHexView.hpp"
  40
  41 const unsigned int BYTES_PER_LINE   = 16;
  42 const unsigned int HEXCHARS_IN_LINE = BYTES_PER_LINE * 3 - 1;
  43 const unsigned int GAP_ADR_HEX      = 10;
  44 const unsigned int GAP_HEX_ASCII    = 10;
  45 const unsigned int GAP_ASCII_SLIDER = 5;
  46
  47
  48 QHexView::QHexView(QWidget *parent):
  49         QAbstractScrollArea(parent),
  50         data_(nullptr)
  51 {
  52         setFont(QFont("Courier", 10));
  53
  54         charWidth_ = fontMetrics().boundingRect('X').width();
  55         charHeight_ = fontMetrics().height();
  56
  57         // Determine X coordinates of the three sub-areas
  58         posAddr_  = 0;
  59         posHex_   = 10 * charWidth_ + GAP_ADR_HEX;
  60         posAscii_ = posHex_ + HEXCHARS_IN_LINE * charWidth_ + GAP_HEX_ASCII;
  61
  62         setFocusPolicy(Qt::StrongFocus);
  63 }
  64
  65 void QHexView::setData(QByteArray *data)
  66 {
  67         verticalScrollBar()->setValue(0);
  68
  69         data_ = data;
  70         cursorPos_ = 0;
  71         resetSelection(0);
  72
  73         viewport()->update();
  74 }
  75
  76 void QHexView::showFromOffset(size_t offset)
  77 {
  78         if (data_ && (offset < (size_t)data_->count())) {
  79                 setCursorPos(offset * 2);
  80
  81                 int cursorY = cursorPos_ / (2 * BYTES_PER_LINE);
  82                 verticalScrollBar() -> setValue(cursorY);
  83         }
  84
  85         viewport()->update();
  86 }
  87
  88 void QHexView::clear()
  89 {
  90         verticalScrollBar()->setValue(0);
  91         data_ = nullptr;
  92
  93         viewport()->update();
  94 }
  95
  96 QSize QHexView::getFullSize() const
  97 {
  98         size_t width = posAscii_ + (BYTES_PER_LINE * charWidth_) +
  99                 GAP_ASCII_SLIDER + verticalScrollBar()->width();
 100
 101         if (!data_)
 102                 return QSize(width, 0);
 103
 104         size_t height = data_->count() / BYTES_PER_LINE;
 105
 106         if (data_->count() % BYTES_PER_LINE)
 107                 height++;
 108
 109         height *= charHeight_;
 110
 111         return QSize(width, height);
 112 }
 113
 114 void QHexView::paintEvent(QPaintEvent *event)
 115 {
 116         QPainter painter(viewport());
 117
 118         // Calculate and update the widget and paint area sizes
 119         QSize widgetSize = getFullSize();
 120         setMinimumWidth(widgetSize.width());
 121         setMaximumWidth(widgetSize.width());
 122         QSize areaSize = viewport()->size();
 123
 124         verticalScrollBar()->setPageStep(areaSize.height() / charHeight_);
 125         verticalScrollBar()->setRange(0, (widgetSize.height() - areaSize.height()) / charHeight_ + 1);
 126
 127         // Fill widget background
 128         painter.fillRect(event->rect(), palette().color(QPalette::Base));
 129
 130         if (!data_ || (data_->size() == 0)) {
 131                 painter.setPen(palette().color(QPalette::Text));
 132                 QString s = tr("No data available");
 133                 int x = (areaSize.width() - fontMetrics().boundingRect(s).width()) / 2;
 134                 int y = areaSize.height() / 2;
 135                 painter.drawText(x, y, s);
 136                 return;
 137         }
 138
 139         // Determine first/last line indices
 140         size_t firstLineIdx = verticalScrollBar()->value();
 141
 142         size_t lastLineIdx = firstLineIdx + areaSize.height() / charHeight_;
 143         if (lastLineIdx > (data_->count() / BYTES_PER_LINE)) {
 144                 lastLineIdx = data_->count() / BYTES_PER_LINE;
 145                 if (data_->count() % BYTES_PER_LINE)
 146                         lastLineIdx++;
 147         }
 148
 149         // Fill address area background
 150         painter.fillRect(QRect(posAddr_, event->rect().top(),
 151                 posHex_ - (GAP_ADR_HEX / 2), height()), palette().color(QPalette::Window));
 152
 153         // Paint divider line between hex and ASCII areas
 154         int line_x = posAscii_ - (GAP_HEX_ASCII / 2);
 155         painter.setPen(palette().color(QPalette::Midlight));
 156         painter.drawLine(line_x, event->rect().top(), line_x, height());
 157
 158         // Paint address area
 159         painter.setPen(palette().color(QPalette::ButtonText));
 160
 161         int yStart = charHeight_;
 162         for (size_t lineIdx = firstLineIdx, y = yStart; lineIdx < lastLineIdx; lineIdx++) {
 163
 164                 QString address = QString("%1").arg(lineIdx * 16, 10, 16, QChar('0')).toUpper();
 165                 painter.drawText(posAddr_, y, address);
 166                 y += charHeight_;
 167         }
 168
 169         // Paint hex values
 170         QBrush regular = painter.brush();
 171         QBrush selected = QBrush(palette().color(QPalette::Highlight));
 172         QByteArray data = data_->mid(firstLineIdx * BYTES_PER_LINE,
 173                 (lastLineIdx - firstLineIdx) * BYTES_PER_LINE);
 174
 175         yStart = charHeight_;
 176         for (size_t lineIdx = firstLineIdx, y = yStart; lineIdx < lastLineIdx; lineIdx++) {
 177
 178                 painter.setBackgroundMode(Qt::OpaqueMode);
 179
 180                 int x = posHex_;
 181                 for (size_t i = 0; i < BYTES_PER_LINE && ((lineIdx - firstLineIdx) * BYTES_PER_LINE + i) < (size_t)data.size(); i++) {
 182                         size_t pos = (lineIdx * BYTES_PER_LINE + i) * 2;
 183
 184                         if ((pos >= selectBegin_) && (pos < selectEnd_)) {
 185                                 painter.setBackground(selected);
 186                                 painter.setPen(palette().color(QPalette::HighlightedText));
 187                         } else {
 188                                 painter.setBackground(regular);
 189                                 painter.setPen(palette().color(QPalette::Text));
 190                         }
 191
 192                         // First nibble
 193                         QString val = QString::number((data.at((lineIdx - firstLineIdx) * BYTES_PER_LINE + i) & 0xF0) >> 4, 16).toUpper();
 194                         painter.drawText(x, y, val);
 195
 196                         // Second nibble
 197                         val = QString::number((data.at((lineIdx - firstLineIdx) * BYTES_PER_LINE + i) & 0xF), 16).toUpper();
 198                         painter.drawText(x + charWidth_, y, val);
 199
 200                         x += 3 * charWidth_;
 201                 }
 202
 203                 y += charHeight_;
 204         }
 205
 206         // Paint ASCII characters
 207         yStart = charHeight_;
 208         for (size_t lineIdx = firstLineIdx, y = yStart; lineIdx < lastLineIdx; lineIdx++) {
 209
 210                 int x = posAscii_;
 211                 for (size_t i = 0; ((lineIdx - firstLineIdx) * BYTES_PER_LINE + i) < (size_t)data.size() && (i < BYTES_PER_LINE); i++) {
 212                         char ch = data[(unsigned int)((lineIdx - firstLineIdx) * BYTES_PER_LINE + i)];
 213
 214                         if ((ch < 0x20) || (ch > 0x7E))
 215                                 ch = '.';
 216
 217                         size_t pos = (lineIdx * BYTES_PER_LINE + i) * 2;
 218                         if ((pos >= selectBegin_) && (pos < selectEnd_)) {
 219                                 painter.setBackground(selected);
 220                                 painter.setPen(palette().color(QPalette::HighlightedText));
 221                         } else {
 222                                 painter.setBackground(regular);
 223                                 painter.setPen(palette().color(QPalette::Text));
 224                         }
 225
 226                         painter.drawText(x, y, QString(ch));
 227                         x += charWidth_;
 228                 }
 229
 230                 y += charHeight_;
 231         }
 232
 233         // Paint cursor
 234         if (hasFocus()) {
 235                 int x = (cursorPos_ % (2 * BYTES_PER_LINE));
 236                 int y = cursorPos_ / (2 * BYTES_PER_LINE);
 237                 y -= firstLineIdx;
 238                 int cursorX = (((x / 2) * 3) + (x % 2)) * charWidth_ + posHex_;
 239                 int cursorY = y * charHeight_ + 4;
 240                 painter.fillRect(cursorX, cursorY, 2, charHeight_, palette().color(QPalette::WindowText));
 241         }
 242 }
 243
 244 void QHexView::keyPressEvent(QKeyEvent *event)
 245 {
 246         bool setVisible = false;
 247
 248         // Cursor movements
 249         if (event->matches(QKeySequence::MoveToNextChar)) {
 250                 setCursorPos(cursorPos_ + 1);
 251                 resetSelection(cursorPos_);
 252                 setVisible = true;
 253         }
 254         if (event->matches(QKeySequence::MoveToPreviousChar)) {
 255                 setCursorPos(cursorPos_ - 1);
 256                 resetSelection(cursorPos_);
 257                 setVisible = true;
 258         }
 259
 260         if (event->matches(QKeySequence::MoveToEndOfLine)) {
 261                 setCursorPos(cursorPos_ | ((BYTES_PER_LINE * 2) - 1));
 262                 resetSelection(cursorPos_);
 263                 setVisible = true;
 264         }
 265         if (event->matches(QKeySequence::MoveToStartOfLine)) {
 266                 setCursorPos(cursorPos_ | (cursorPos_ % (BYTES_PER_LINE * 2)));
 267                 resetSelection(cursorPos_);
 268                 setVisible = true;
 269         }
 270         if (event->matches(QKeySequence::MoveToPreviousLine)) {
 271                 setCursorPos(cursorPos_ - BYTES_PER_LINE * 2);
 272                 resetSelection(cursorPos_);
 273                 setVisible = true;
 274         }
 275         if (event->matches(QKeySequence::MoveToNextLine)) {
 276                 setCursorPos(cursorPos_ + BYTES_PER_LINE * 2);
 277                 resetSelection(cursorPos_);
 278                 setVisible = true;
 279         }
 280
 281         if (event->matches(QKeySequence::MoveToNextPage)) {
 282                 setCursorPos(cursorPos_ + (viewport()->height() / charHeight_ - 1) * 2 * BYTES_PER_LINE);
 283                 resetSelection(cursorPos_);
 284                 setVisible = true;
 285         }
 286         if (event->matches(QKeySequence::MoveToPreviousPage)) {
 287                 setCursorPos(cursorPos_ - (viewport()->height() / charHeight_ - 1) * 2 * BYTES_PER_LINE);
 288                 resetSelection(cursorPos_);
 289                 setVisible = true;
 290         }
 291         if (event->matches(QKeySequence::MoveToEndOfDocument)) {
 292                 if (data_)
 293                         setCursorPos(data_->count() * 2);
 294                 resetSelection(cursorPos_);
 295                 setVisible = true;
 296         }
 297         if (event->matches(QKeySequence::MoveToStartOfDocument)) {
 298                 setCursorPos(0);
 299                 resetSelection(cursorPos_);
 300                 setVisible = true;
 301         }
 302
 303         // Select commands
 304         if (event->matches(QKeySequence::SelectAll)) {
 305                 resetSelection(0);
 306                 if (data_)
 307                         setSelection(2 * data_->count() + 1);
 308                 setVisible = true;
 309         }
 310         if (event->matches(QKeySequence::SelectNextChar)) {
 311                 int pos = cursorPos_ + 1;
 312                 setCursorPos(pos);
 313                 setSelection(pos);
 314                 setVisible = true;
 315         }
 316         if (event->matches(QKeySequence::SelectPreviousChar)) {
 317                 int pos = cursorPos_ - 1;
 318                 setSelection(pos);
 319                 setCursorPos(pos);
 320                 setVisible = true;
 321         }
 322         if (event->matches(QKeySequence::SelectEndOfLine)) {
 323                 int pos = cursorPos_ - (cursorPos_ % (2 * BYTES_PER_LINE)) + (2 * BYTES_PER_LINE);
 324                 setCursorPos(pos);
 325                 setSelection(pos);
 326                 setVisible = true;
 327         }
 328         if (event->matches(QKeySequence::SelectStartOfLine)) {
 329                 int pos = cursorPos_ - (cursorPos_ % (2 * BYTES_PER_LINE));
 330                 setCursorPos(pos);
 331                 setSelection(pos);
 332                 setVisible = true;
 333         }
 334         if (event->matches(QKeySequence::SelectPreviousLine)) {
 335                 int pos = cursorPos_ - (2 * BYTES_PER_LINE);
 336                 setCursorPos(pos);
 337                 setSelection(pos);
 338                 setVisible = true;
 339         }
 340         if (event->matches(QKeySequence::SelectNextLine)) {
 341                 int pos = cursorPos_ + (2 * BYTES_PER_LINE);
 342                 setCursorPos(pos);
 343                 setSelection(pos);
 344                 setVisible = true;
 345         }
 346
 347         if (event->matches(QKeySequence::SelectNextPage)) {
 348                 int pos = cursorPos_ + (((viewport()->height() / charHeight_) - 1) * 2 * BYTES_PER_LINE);
 349                 setCursorPos(pos);
 350                 setSelection(pos);
 351                 setVisible = true;
 352         }
 353         if (event->matches(QKeySequence::SelectPreviousPage)) {
 354                 int pos = cursorPos_ - (((viewport()->height() / charHeight_) - 1) * 2 * BYTES_PER_LINE);
 355                 setCursorPos(pos);
 356                 setSelection(pos);
 357                 setVisible = true;
 358         }
 359         if (event->matches(QKeySequence::SelectEndOfDocument)) {
 360                 int pos = 0;
 361                 if (data_)
 362                         pos = data_->count() * 2;
 363                 setCursorPos(pos);
 364                 setSelection(pos);
 365                 setVisible = true;
 366         }
 367         if (event->matches(QKeySequence::SelectStartOfDocument)) {
 368                 int pos = 0;
 369                 setCursorPos(pos);
 370                 setSelection(pos);
 371                 setVisible = true;
 372         }
 373
 374         if (event->matches(QKeySequence::Copy) && (data_)) {
 375                 QString text;
 376                 int idx = 0;
 377                 int copyOffset = 0;
 378
 379                 QByteArray data = data_->mid(selectBegin_ / 2, (selectEnd_ - selectBegin_) / 2 + 1);
 380                 if (selectBegin_ % 2) {
 381                         text += QString::number((data.at((idx+1) / 2) & 0xF), 16);
 382                         text += " ";
 383                         idx++;
 384                         copyOffset = 1;
 385                 }
 386
 387                 int selectedSize = selectEnd_ - selectBegin_;
 388                 while (idx < selectedSize) {
 389                         QString val = QString::number((data.at((copyOffset + idx) / 2) & 0xF0) >> 4, 16);
 390                         if ((idx + 1) < selectedSize) {
 391                                 val += QString::number((data.at((copyOffset + idx) / 2) & 0xF), 16);
 392                                 val += " ";
 393                         }
 394                         text += val;
 395
 396                         if ((idx/2) % BYTES_PER_LINE == (BYTES_PER_LINE - 1))
 397                                 text += "\n";
 398
 399                         idx += 2;
 400                 }
 401
 402                 QClipboard *clipboard = QApplication::clipboard();
 403                 clipboard->setText(text);
 404                 if (clipboard->supportsSelection())
 405                         clipboard->setText(text);
 406         }
 407
 408         if (setVisible)
 409                 ensureVisible();
 410
 411         viewport()->update();
 412 }
 413
 414 void QHexView::mouseMoveEvent(QMouseEvent *event)
 415 {
 416         int actPos = cursorPosFromMousePos(event->pos());
 417         setCursorPos(actPos);
 418         setSelection(actPos);
 419
 420         viewport()->update();
 421 }
 422
 423 void QHexView::mousePressEvent(QMouseEvent *event)
 424 {
 425         int cPos = cursorPosFromMousePos(event->pos());
 426
 427         if ((QApplication::keyboardModifiers() & Qt::ShiftModifier) && (event->button() == Qt::LeftButton))
 428                 setSelection(cPos);
 429         else
 430                 resetSelection(cPos);
 431
 432         setCursorPos(cPos);
 433
 434         viewport()->update();
 435 }
 436
 437 size_t QHexView::cursorPosFromMousePos(const QPoint &position)
 438 {
 439         int pos = -1;
 440
 441         if (((size_t)position.x() >= posHex_) &&
 442                 ((size_t)position.x() < (posHex_ + HEXCHARS_IN_LINE * charWidth_))) {
 443
 444                 // Note: We add 1.5 character widths so that selection across
 445                 // byte gaps is smoother
 446                 int x = (position.x() + (1.5 * charWidth_ / 2) - posHex_) / charWidth_;
 447
 448                 // Note: We allow only full bytes to be selected, not nibbles,
 449                 // so we round to the nearest byte gap
 450                 x = (2 * x + 1) / 3;
 451
 452                 int firstLineIdx = verticalScrollBar()->value();
 453                 int y = (position.y() / charHeight_) * 2 * BYTES_PER_LINE;
 454                 pos = x + y + firstLineIdx * BYTES_PER_LINE * 2;
 455         }
 456
 457         return pos;
 458 }
 459
 460 void QHexView::resetSelection()
 461 {
 462         selectBegin_ = selectInit_;
 463         selectEnd_ = selectInit_;
 464 }
 465
 466 void QHexView::resetSelection(int pos)
 467 {
 468         if (pos < 0)
 469                 pos = 0;
 470
 471         selectInit_ = pos;
 472         selectBegin_ = pos;
 473         selectEnd_ = pos;
 474 }
 475
 476 void QHexView::setSelection(int pos)
 477 {
 478         if (pos < 0)
 479                 pos = 0;
 480
 481         if ((size_t)pos >= selectInit_) {
 482                 selectEnd_ = pos;
 483                 selectBegin_ = selectInit_;
 484         } else {
 485                 selectBegin_ = pos;
 486                 selectEnd_ = selectInit_;
 487         }
 488 }
 489
 490 void QHexView::setCursorPos(int position)
 491 {
 492         if (position < 0)
 493                 position = 0;
 494
 495         int maxPos = 0;
 496         if (data_)
 497                 maxPos = data_->count() * 2;
 498
 499         if (position > maxPos)
 500                 position = maxPos;
 501
 502         cursorPos_ = position;
 503 }
 504
 505 void QHexView::ensureVisible()
 506 {
 507         QSize areaSize = viewport()->size();
 508
 509         int firstLineIdx = verticalScrollBar() -> value();
 510         int lastLineIdx = firstLineIdx + areaSize.height() / charHeight_;
 511
 512         int cursorY = cursorPos_ / (2 * BYTES_PER_LINE);
 513
 514         if (cursorY < firstLineIdx)
 515                 verticalScrollBar() -> setValue(cursorY);
 516         else if(cursorY >= lastLineIdx)
 517                 verticalScrollBar() -> setValue(cursorY - areaSize.height() / charHeight_ + 1);
 518 }