cutter/src/widgets/DisassemblyWidget.cpp

729 lines
23 KiB
C++
Raw Normal View History

#include "DisassemblyWidget.h"
#include "menus/DisassemblyContextMenu.h"
2018-10-17 07:55:53 +00:00
#include "common/HexAsciiHighlighter.h"
#include "common/HexHighlighter.h"
#include "common/Configuration.h"
#include "common/Helpers.h"
#include "common/TempConfig.h"
2017-10-16 19:00:47 +00:00
#include <QScrollBar>
#include <QJsonArray>
#include <QJsonObject>
#include <QVBoxLayout>
#include <QRegularExpression>
#include <QTextBlockUserData>
class DisassemblyTextBlockUserData: public QTextBlockUserData
{
public:
DisassemblyLine line;
explicit DisassemblyTextBlockUserData(const DisassemblyLine &line)
{
this->line = line;
}
};
static DisassemblyTextBlockUserData *getUserData(const QTextBlock &block)
{
QTextBlockUserData *userData = block.userData();
2018-03-21 20:32:32 +00:00
if (!userData) {
return nullptr;
}
return static_cast<DisassemblyTextBlockUserData *>(userData);
}
DisassemblyWidget::DisassemblyWidget(MainWindow *main, QAction *action)
: CutterDockWidget(main, action)
, mCtxMenu(new DisassemblyContextMenu(this))
, mDisasScrollArea(new DisassemblyScrollArea(this))
, mDisasTextEdit(new DisassemblyTextEdit(this))
, seekable(new CutterSeekable(this))
{
topOffset = bottomOffset = RVA_INVALID;
cursorLineOffset = 0;
seekFromCursor = false;
setWindowTitle(tr("Disassembly"));
QVBoxLayout *layout = new QVBoxLayout();
layout->addWidget(mDisasTextEdit);
layout->setMargin(0);
mDisasScrollArea->viewport()->setLayout(layout);
mDisasScrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setWidget(mDisasScrollArea);
setAllowedAreas(Qt::AllDockWidgetAreas);
setObjectName("DisassemblyWidget");
2017-11-30 14:00:22 +00:00
setupFonts();
setupColors();
2019-01-13 13:59:08 +00:00
disasmRefresh = createReplacingRefreshDeferrer<RVA>(false, [this](const RVA *offset) {
refreshDisasm(offset ? *offset : RVA_INVALID);
2019-01-12 19:25:43 +00:00
});
2017-11-30 14:00:22 +00:00
maxLines = 0;
updateMaxLines();
mDisasTextEdit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
mDisasTextEdit->setFont(Config()->getFont());
2017-10-16 19:00:47 +00:00
mDisasTextEdit->setReadOnly(true);
mDisasTextEdit->setLineWrapMode(QPlainTextEdit::WidgetWidth);
// wrapping breaks readCurrentDisassemblyOffset() at the moment :-(
mDisasTextEdit->setWordWrapMode(QTextOption::NoWrap);
// Increase asm text edit margin
QTextDocument *asm_docu = mDisasTextEdit->document();
asm_docu->setDocumentMargin(10);
// Event filter to intercept double clicks in the textbox
mDisasTextEdit->viewport()->installEventFilter(this);
// Set Disas context menu
mDisasTextEdit->setContextMenuPolicy(Qt::CustomContextMenu);
connect(mDisasTextEdit, SIGNAL(customContextMenuRequested(const QPoint &)),
this, SLOT(showDisasContextMenu(const QPoint &)));
// Space to switch to graph
QShortcut *graphShortcut = new QShortcut(QKeySequence(Qt::Key_Space), this);
graphShortcut->setContext(Qt::WidgetWithChildrenShortcut);
2018-03-21 20:32:32 +00:00
connect(graphShortcut, &QShortcut::activated, this, [] {
Core()->setMemoryWidgetPriority(CutterCore::MemoryWidgetType::Graph);
Core()->triggerRaisePrioritizedMemoryWidget();
});
connect(mDisasScrollArea, SIGNAL(scrollLines(int)), this, SLOT(scrollInstructions(int)));
connect(mDisasScrollArea, SIGNAL(disassemblyResized()), this, SLOT(updateMaxLines()));
connectCursorPositionChanged(false);
2018-03-21 20:32:32 +00:00
connect(mDisasTextEdit->verticalScrollBar(), &QScrollBar::valueChanged, this, [ = ](int value) {
if (value != 0) {
mDisasTextEdit->verticalScrollBar()->setValue(0);
}
});
2018-03-21 20:32:32 +00:00
connect(Core(), SIGNAL(raisePrioritizedMemoryWidget(CutterCore::MemoryWidgetType)), this,
SLOT(raisePrioritizedMemoryWidget(CutterCore::MemoryWidgetType)));
connect(Core(), SIGNAL(commentsChanged()), this, SLOT(refreshDisasm()));
connect(Core(), SIGNAL(flagsChanged()), this, SLOT(refreshDisasm()));
connect(Core(), SIGNAL(functionsChanged()), this, SLOT(refreshDisasm()));
2018-03-21 20:32:32 +00:00
connect(Core(), SIGNAL(functionRenamed(const QString &, const QString &)), this,
SLOT(refreshDisasm()));
connect(Core(), SIGNAL(varsChanged()), this, SLOT(refreshDisasm()));
connect(Core(), SIGNAL(asmOptionsChanged()), this, SLOT(refreshDisasm()));
connect(Core(), &CutterCore::instructionChanged, this, [this](RVA offset) {
2018-03-21 20:32:32 +00:00
if (offset >= topOffset && offset <= bottomOffset) {
refreshDisasm();
}
});
connect(Core(), SIGNAL(refreshCodeViews()), this, SLOT(refreshDisasm()));
connect(Config(), SIGNAL(fontsUpdated()), this, SLOT(fontsUpdatedSlot()));
2017-11-20 11:23:37 +00:00
connect(Config(), SIGNAL(colorsUpdated()), this, SLOT(colorsUpdatedSlot()));
connect(this, &QDockWidget::visibilityChanged, this, [](bool visibility) {
2018-09-30 20:00:53 +00:00
bool emptyGraph = (Core()->getMemoryWidgetPriority() == CutterCore::MemoryWidgetType::Graph
&& Core()->isGraphEmpty());
if (visibility && !emptyGraph) {
Core()->setMemoryWidgetPriority(CutterCore::MemoryWidgetType::Disassembly);
}
});
connect(Core(), &CutterCore::refreshAll, this, [this]() {
refreshDisasm(seekable->getOffset());
});
2017-12-02 15:43:21 +00:00
connect(mCtxMenu, SIGNAL(copy()), mDisasTextEdit, SLOT(copy()));
// Dirty
QShortcut *shortcut_escape = new QShortcut(QKeySequence(Qt::Key_Escape), this);
shortcut_escape->setContext(Qt::WidgetShortcut);
connect(shortcut_escape, SIGNAL(activated()), this, SLOT(seekPrev()));
mCtxMenu->addSeparator();
syncIt.setText(tr("Sync/unsync offset"));
mCtxMenu->addAction(&syncIt);
connect(&syncIt, SIGNAL(triggered(bool)), this, SLOT(toggleSync()));
connect(seekable, &CutterSeekable::seekableSeekChanged, this, &DisassemblyWidget::on_seekChanged);
#define ADD_SHORTCUT(ksq, slot) { \
QShortcut *s = new QShortcut((ksq), this); \
s->setContext(Qt::WidgetShortcut); \
connect(s, &QShortcut::activated, this, (slot)); \
}
2018-03-21 20:32:32 +00:00
ADD_SHORTCUT(QKeySequence(Qt::Key_J), [this]() {
moveCursorRelative(false, false);
})
ADD_SHORTCUT(QKeySequence::MoveToNextLine, [this]() {
moveCursorRelative(false, false);
})
ADD_SHORTCUT(QKeySequence(Qt::Key_K), [this]() {
moveCursorRelative(true, false);
})
ADD_SHORTCUT(QKeySequence::MoveToPreviousLine, [this]() {
moveCursorRelative(true, false);
})
ADD_SHORTCUT(QKeySequence::MoveToNextPage, [this]() {
moveCursorRelative(false, true);
})
ADD_SHORTCUT(QKeySequence::MoveToPreviousPage, [this]() {
moveCursorRelative(true, true);
})
ADD_SHORTCUT(QKeySequence(Qt::CTRL + Qt::Key_Plus), &DisassemblyWidget::zoomIn)
ADD_SHORTCUT(QKeySequence(Qt::CTRL + Qt::Key_Minus), &DisassemblyWidget::zoomOut)
#undef ADD_SHORTCUT
}
void DisassemblyWidget::toggleSync()
{
QString windowTitle = tr("Disassembly");
seekable->toggleSynchronization();
if (seekable->isSynchronized()) {
setWindowTitle(windowTitle);
} else {
setWindowTitle(windowTitle + CutterSeekable::tr(" (unsynced)"));
}
}
2018-03-21 20:32:32 +00:00
QWidget *DisassemblyWidget::getTextWidget()
2017-10-22 10:21:44 +00:00
{
return mDisasTextEdit;
}
void DisassemblyWidget::refreshDisasm(RVA offset)
2017-10-22 13:55:42 +00:00
{
2019-01-13 13:59:08 +00:00
if(!disasmRefresh->attemptRefresh(offset == RVA_INVALID ? nullptr : new RVA(offset))) {
return;
}
2018-03-21 20:32:32 +00:00
if (offset != RVA_INVALID) {
topOffset = offset;
}
2018-03-21 20:32:32 +00:00
if (topOffset == RVA_INVALID) {
return;
}
2018-03-21 20:32:32 +00:00
if (maxLines <= 0) {
2017-11-18 12:56:48 +00:00
connectCursorPositionChanged(true);
mDisasTextEdit->clear();
2017-11-18 12:56:48 +00:00
connectCursorPositionChanged(false);
return;
}
breakpoints = Core()->getBreakpointsAddresses();
int horizontalScrollValue = mDisasTextEdit->horizontalScrollBar()->value();
mDisasTextEdit->setLockScroll(true); // avoid flicker
2018-03-21 20:32:32 +00:00
QList<DisassemblyLine> disassemblyLines;
{
TempConfig tempConfig;
2019-02-14 21:47:39 +00:00
tempConfig.set("scr.color", COLOR_MODE_16M);
disassemblyLines = Core()->disassembleLines(topOffset, maxLines);
}
connectCursorPositionChanged(true);
2017-10-22 13:55:42 +00:00
mDisasTextEdit->document()->clear();
QTextCursor cursor(mDisasTextEdit->document());
QTextBlockFormat regular = cursor.blockFormat();
for (const DisassemblyLine &line : disassemblyLines) {
if (line.offset < topOffset) { // overflow
break;
}
cursor.insertHtml(line.text);
2018-09-30 20:00:53 +00:00
if (Core()->isBreakpoint(breakpoints, line.offset)) {
QTextBlockFormat f;
f.setBackground(ConfigColor("gui.breakpoint_background"));
cursor.setBlockFormat(f);
}
auto a = new DisassemblyTextBlockUserData(line);
cursor.block().setUserData(a);
cursor.insertBlock();
cursor.setBlockFormat(regular);
}
if (!disassemblyLines.isEmpty()) {
bottomOffset = disassemblyLines[qMin(disassemblyLines.size(), maxLines) - 1].offset;
if (bottomOffset < topOffset) {
bottomOffset = RVA_MAX;
}
} else {
bottomOffset = topOffset;
}
// remove additional lines
QTextCursor tc = mDisasTextEdit->textCursor();
tc.movePosition(QTextCursor::Start);
tc.movePosition(QTextCursor::Down, QTextCursor::MoveAnchor, maxLines - 1);
tc.movePosition(QTextCursor::EndOfLine);
tc.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
tc.removeSelectedText();
connectCursorPositionChanged(false);
updateCursorPosition();
mDisasTextEdit->setLockScroll(false);
mDisasTextEdit->horizontalScrollBar()->setValue(horizontalScrollValue);
}
void DisassemblyWidget::scrollInstructions(int count)
{
2018-03-21 20:32:32 +00:00
if (count == 0) {
return;
2017-10-22 13:55:42 +00:00
}
RVA offset;
2018-03-21 20:32:32 +00:00
if (count > 0) {
offset = Core()->nextOpAddr(topOffset, count);
if (offset < topOffset) {
offset = RVA_MAX;
}
2018-03-21 20:32:32 +00:00
} else {
offset = Core()->prevOpAddr(topOffset, -count);
if (offset > topOffset) {
offset = 0;
}
}
refreshDisasm(offset);
}
bool DisassemblyWidget::updateMaxLines()
{
int currentMaxLines = qhelpers::getMaxFullyDisplayedLines(mDisasTextEdit);
2018-03-21 20:32:32 +00:00
if (currentMaxLines != maxLines) {
maxLines = currentMaxLines;
refreshDisasm();
return true;
}
return false;
}
2018-09-30 20:00:53 +00:00
void DisassemblyWidget::zoomIn()
{
mDisasTextEdit->zoomIn();
updateMaxLines();
}
2018-09-30 20:00:53 +00:00
void DisassemblyWidget::zoomOut()
{
mDisasTextEdit->zoomOut();
updateMaxLines();
}
2017-10-22 13:55:42 +00:00
void DisassemblyWidget::highlightCurrentLine()
{
2017-10-22 13:55:42 +00:00
QList<QTextEdit::ExtraSelection> extraSelections;
2017-12-02 15:03:55 +00:00
QColor highlightColor = ConfigColor("highlight");
QColor highlightPCColor = ConfigColor("highlightPC");
QColor highlightWordColor = ConfigColor("highlightWord");
2017-12-02 15:03:55 +00:00
2017-10-22 13:55:42 +00:00
// Highlight the current word
QTextCursor cursor = mDisasTextEdit->textCursor();
cursor.select(QTextCursor::WordUnderCursor);
2017-12-02 15:03:55 +00:00
QString searchString = cursor.selectedText();
2017-12-02 15:03:55 +00:00
cursor.movePosition(QTextCursor::StartOfLine);
int listStartPos = cursor.position();
cursor.movePosition(QTextCursor::EndOfLine);
int lineEndPos = cursor.position();
2017-10-22 13:55:42 +00:00
// Highlight the current line
QTextEdit::ExtraSelection highlightSelection;
highlightSelection.cursor = cursor;
highlightSelection.cursor.movePosition(QTextCursor::Start);
while (true) {
RVA lineOffset = readDisassemblyOffset(highlightSelection.cursor);
if (lineOffset == seekable->getOffset()) {
highlightSelection.format.setBackground(highlightColor);
highlightSelection.format.setProperty(QTextFormat::FullWidthSelection, true);
highlightSelection.cursor.clearSelection();
extraSelections.append(highlightSelection);
} else if (lineOffset != RVA_INVALID && lineOffset > seekable->getOffset()) {
break;
}
highlightSelection.cursor.movePosition(QTextCursor::EndOfLine);
if (highlightSelection.cursor.atEnd()) {
break;
}
highlightSelection.cursor.movePosition(QTextCursor::Down);
}
2017-12-02 15:03:55 +00:00
// Highlight all the words in the document same as the current one
2017-10-22 13:55:42 +00:00
QTextDocument *document = mDisasTextEdit->document();
highlightSelection.cursor = cursor;
highlightSelection.cursor.movePosition(QTextCursor::Start, QTextCursor::MoveAnchor);
2017-12-02 15:03:55 +00:00
2018-03-21 20:32:32 +00:00
while (!highlightSelection.cursor.isNull() && !highlightSelection.cursor.atEnd()) {
highlightSelection.cursor = document->find(searchString, highlightSelection.cursor,
QTextDocument::FindWholeWords);
2018-03-21 20:32:32 +00:00
if (!highlightSelection.cursor.isNull()) {
if (highlightSelection.cursor.position() >= listStartPos
&& highlightSelection.cursor.position() <= lineEndPos) {
2018-12-16 07:07:25 +00:00
highlightSelection.format.setBackground(highlightWordColor);
2018-03-21 20:32:32 +00:00
} else {
2017-12-02 15:03:55 +00:00
highlightSelection.format.setBackground(highlightWordColor);
}
2017-10-22 13:55:42 +00:00
extraSelections.append(highlightSelection);
}
}
2017-10-13 13:53:23 +00:00
// highlight PC line
RVA PCAddr = Core()->getProgramCounterValue();
highlightSelection.cursor = cursor;
highlightSelection.cursor.movePosition(QTextCursor::Start);
if (PCAddr != RVA_INVALID) {
while (true) {
RVA lineOffset = readDisassemblyOffset(highlightSelection.cursor);
if (lineOffset == PCAddr) {
highlightSelection.format.setBackground(highlightPCColor);
highlightSelection.format.setProperty(QTextFormat::FullWidthSelection, true);
highlightSelection.cursor.clearSelection();
extraSelections.append(highlightSelection);
} else if (lineOffset != RVA_INVALID && lineOffset > PCAddr) {
break;
}
highlightSelection.cursor.movePosition(QTextCursor::EndOfLine);
if (highlightSelection.cursor.atEnd()) {
break;
}
highlightSelection.cursor.movePosition(QTextCursor::Down);
}
}
2017-10-22 13:55:42 +00:00
mDisasTextEdit->setExtraSelections(extraSelections);
}
void DisassemblyWidget::showDisasContextMenu(const QPoint &pt)
{
mCtxMenu->exec(mDisasTextEdit->mapToGlobal(pt));
2017-10-22 13:55:42 +00:00
}
RVA DisassemblyWidget::readCurrentDisassemblyOffset()
2017-11-28 11:56:38 +00:00
{
QTextCursor tc = mDisasTextEdit->textCursor();
return readDisassemblyOffset(tc);
}
RVA DisassemblyWidget::readDisassemblyOffset(QTextCursor tc)
2017-10-22 13:55:42 +00:00
{
auto userData = getUserData(tc.block());
2018-03-21 20:32:32 +00:00
if (!userData) {
return RVA_INVALID;
2017-10-22 13:55:42 +00:00
}
return userData->line.offset;
2017-10-22 13:55:42 +00:00
}
void DisassemblyWidget::updateCursorPosition()
2017-10-22 13:55:42 +00:00
{
RVA offset = seekable->getOffset();
// already fine where it is?
RVA currentLineOffset = readCurrentDisassemblyOffset();
2018-03-21 20:32:32 +00:00
if (currentLineOffset == offset) {
return;
}
connectCursorPositionChanged(true);
2018-03-21 20:32:32 +00:00
if (offset < topOffset || (offset > bottomOffset && bottomOffset != RVA_INVALID)) {
mDisasTextEdit->moveCursor(QTextCursor::Start);
mDisasTextEdit->setExtraSelections({});
2018-03-21 20:32:32 +00:00
} else {
RVA currentCursorOffset = readCurrentDisassemblyOffset();
QTextCursor originalCursor = mDisasTextEdit->textCursor();
QTextCursor cursor = originalCursor;
cursor.movePosition(QTextCursor::Start);
2018-03-21 20:32:32 +00:00
while (true) {
RVA lineOffset = readDisassemblyOffset(cursor);
2018-03-21 20:32:32 +00:00
if (lineOffset == offset) {
if (cursorLineOffset > 0) {
cursor.movePosition(QTextCursor::Down, QTextCursor::MoveAnchor, cursorLineOffset);
}
mDisasTextEdit->setTextCursor(cursor);
highlightCurrentLine();
break;
2018-03-21 20:32:32 +00:00
} else if (lineOffset != RVA_INVALID && lineOffset > offset) {
mDisasTextEdit->moveCursor(QTextCursor::Start);
mDisasTextEdit->setExtraSelections({});
break;
}
cursor.movePosition(QTextCursor::EndOfLine);
2018-03-21 20:32:32 +00:00
if (cursor.atEnd()) {
break;
}
cursor.movePosition(QTextCursor::Down);
}
// this is true if a seek came from the user clicking on a line.
// then the cursor should be restored 1:1 to retain selection and cursor position.
2018-03-21 20:32:32 +00:00
if (currentCursorOffset == offset) {
mDisasTextEdit->setTextCursor(originalCursor);
}
}
connectCursorPositionChanged(false);
}
void DisassemblyWidget::connectCursorPositionChanged(bool disconnect)
{
2018-03-21 20:32:32 +00:00
if (disconnect) {
QObject::disconnect(mDisasTextEdit, SIGNAL(cursorPositionChanged()), this,
SLOT(cursorPositionChanged()));
} else {
connect(mDisasTextEdit, SIGNAL(cursorPositionChanged()), this, SLOT(cursorPositionChanged()));
}
}
void DisassemblyWidget::cursorPositionChanged()
{
RVA offset = readCurrentDisassemblyOffset();
cursorLineOffset = 0;
QTextCursor c = mDisasTextEdit->textCursor();
2018-03-21 20:32:32 +00:00
while (c.blockNumber() > 0) {
c.movePosition(QTextCursor::PreviousBlock);
2018-03-21 20:32:32 +00:00
if (readDisassemblyOffset(c) != offset) {
break;
}
cursorLineOffset++;
}
seekFromCursor = true;
seekable->seek(offset);
seekFromCursor = false;
highlightCurrentLine();
2017-12-02 15:43:21 +00:00
mCtxMenu->setCanCopy(mDisasTextEdit->textCursor().hasSelection());
}
void DisassemblyWidget::moveCursorRelative(bool up, bool page)
{
2018-03-21 20:32:32 +00:00
if (page) {
RVA offset;
2018-03-21 20:32:32 +00:00
if (!up) {
offset = Core()->nextOpAddr(bottomOffset, 1);
if (offset < bottomOffset) {
offset = RVA_MAX;
}
2018-03-21 20:32:32 +00:00
} else {
offset = Core()->prevOpAddr(topOffset, maxLines);
if (offset > topOffset) {
offset = 0;
} else {
// disassembly from calculated offset may have more than maxLines lines
// move some instructions down if necessary.
auto lines = Core()->disassembleLines(offset, maxLines).toVector();
int oldTopLine;
for (oldTopLine = lines.length(); oldTopLine > 0; oldTopLine--) {
if (lines[oldTopLine - 1].offset < topOffset) {
break;
}
}
int overflowLines = oldTopLine - maxLines;
if (overflowLines > 0) {
while (lines[overflowLines - 1].offset == lines[overflowLines].offset
2018-09-30 20:00:53 +00:00
&& overflowLines < lines.length() - 1) {
overflowLines++;
}
offset = lines[overflowLines].offset;
}
}
}
refreshDisasm(offset);
2018-03-21 20:32:32 +00:00
} else { // normal arrow keys
int blockCount = mDisasTextEdit->blockCount();
2018-03-21 20:32:32 +00:00
if (blockCount < 1) {
return;
}
int blockNumber = mDisasTextEdit->textCursor().blockNumber();
2018-03-21 20:32:32 +00:00
if (blockNumber == blockCount - 1 && !up) {
scrollInstructions(1);
2018-03-21 20:32:32 +00:00
} else if (blockNumber == 0 && up) {
scrollInstructions(-1);
}
mDisasTextEdit->moveCursor(up ? QTextCursor::Up : QTextCursor::Down);
// handle cases where top instruction offsets change
RVA offset = readCurrentDisassemblyOffset();
if (offset != seekable->getOffset()) {
seekable->seek(offset);
highlightCurrentLine();
}
}
}
bool DisassemblyWidget::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::MouseButtonDblClick
&& (obj == mDisasTextEdit || obj == mDisasTextEdit->viewport())) {
QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
2017-11-28 11:56:38 +00:00
QTextCursor cursor = mDisasTextEdit->cursorForPosition(QPoint(mouseEvent->x(), mouseEvent->y()));
2017-11-28 11:56:38 +00:00
RVA offset = readDisassemblyOffset(cursor);
RVA jump = Core()->getOffsetJump(offset);
2018-03-21 20:32:32 +00:00
if (jump == RVA_INVALID) {
2017-11-28 11:56:38 +00:00
bool ok;
2018-03-21 20:32:32 +00:00
RVA xref = Core()->cmdj("axfj@" + QString::number(
offset)).array().first().toObject().value("to").toVariant().toULongLong(&ok);
2018-03-21 20:32:32 +00:00
if (ok) {
2017-11-28 11:56:38 +00:00
jump = xref;
}
}
2017-11-28 11:56:38 +00:00
2018-03-21 20:32:32 +00:00
if (jump != RVA_INVALID) {
seekable->seek(jump);
2017-11-28 11:56:38 +00:00
}
return true;
}
return CutterDockWidget::eventFilter(obj, event);
}
void DisassemblyWidget::on_seekChanged(RVA offset)
{
2018-03-21 20:32:32 +00:00
if (!seekFromCursor) {
cursorLineOffset = 0;
}
if (topOffset != RVA_INVALID
2018-03-21 20:32:32 +00:00
&& offset >= topOffset && offset <= bottomOffset) {
// if the line with the seek offset is currently visible, just move the cursor there
updateCursorPosition();
2018-03-21 20:32:32 +00:00
} else {
// otherwise scroll there
refreshDisasm(offset);
}
mCtxMenu->setOffset(offset);
}
void DisassemblyWidget::raisePrioritizedMemoryWidget(CutterCore::MemoryWidgetType type)
{
bool emptyGraph = (type == CutterCore::MemoryWidgetType::Graph && Core()->isGraphEmpty());
if (type == CutterCore::MemoryWidgetType::Disassembly || emptyGraph) {
raise();
setFocus();
}
}
void DisassemblyWidget::fontsUpdatedSlot()
{
2017-11-30 14:00:22 +00:00
setupFonts();
2018-03-21 20:32:32 +00:00
if (!updateMaxLines()) { // updateMaxLines() returns true if it already refreshed.
refreshDisasm();
}
}
2017-10-16 19:00:47 +00:00
2017-11-20 11:23:37 +00:00
void DisassemblyWidget::colorsUpdatedSlot()
{
2017-11-30 14:00:22 +00:00
setupColors();
2017-11-20 11:23:37 +00:00
refreshDisasm();
}
2017-11-30 14:00:22 +00:00
void DisassemblyWidget::setupFonts()
{
mDisasTextEdit->setFont(Config()->getFont());
}
2017-11-30 14:00:22 +00:00
void DisassemblyWidget::setupColors()
{
mDisasTextEdit->setStyleSheet(QString("QPlainTextEdit { background-color: %1; color: %2; }")
2018-03-21 20:32:32 +00:00
.arg(ConfigColor("gui.background").name())
.arg(ConfigColor("btext").name()));
2017-11-30 14:00:22 +00:00
}
DisassemblyScrollArea::DisassemblyScrollArea(QWidget *parent) : QAbstractScrollArea(parent)
{
}
bool DisassemblyScrollArea::viewportEvent(QEvent *event)
{
int dy = verticalScrollBar()->value() - 5;
2018-03-21 20:32:32 +00:00
if (dy != 0) {
emit scrollLines(dy);
}
2018-03-21 20:32:32 +00:00
if (event->type() == QEvent::Resize) {
emit disassemblyResized();
}
resetScrollBars();
return QAbstractScrollArea::viewportEvent(event);
}
void DisassemblyScrollArea::resetScrollBars()
{
verticalScrollBar()->blockSignals(true);
verticalScrollBar()->setRange(0, 10);
verticalScrollBar()->setValue(5);
verticalScrollBar()->blockSignals(false);
}
bool DisassemblyTextEdit::viewportEvent(QEvent *event)
{
2018-03-21 20:32:32 +00:00
switch (event->type()) {
case QEvent::Type::Wheel:
return false;
default:
return QAbstractScrollArea::viewportEvent(event);
}
}
void DisassemblyTextEdit::scrollContentsBy(int dx, int dy)
{
2018-03-21 20:32:32 +00:00
if (!lockScroll) {
QPlainTextEdit::scrollContentsBy(dx, dy);
}
}
void DisassemblyTextEdit::keyPressEvent(QKeyEvent *event)
{
Q_UNUSED(event)
//QPlainTextEdit::keyPressEvent(event);
}
void DisassemblyTextEdit::mousePressEvent(QMouseEvent *event)
{
QPlainTextEdit::mousePressEvent(event);
2018-03-21 20:32:32 +00:00
if (event->button() == Qt::RightButton && !textCursor().hasSelection()) {
setTextCursor(cursorForPosition(event->pos()));
}
}
void DisassemblyWidget::seekPrev()
{
Core()->seekPrev();
}