dolphin/Source/Core/DolphinQt/Debugger/WatchWidget.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

353 lines
9.3 KiB
C++
Raw Normal View History

2017-09-27 06:53:05 +00:00
// Copyright 2017 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
2018-07-06 22:40:15 +00:00
#include "DolphinQt/Debugger/WatchWidget.h"
2017-09-27 06:53:05 +00:00
2019-03-04 19:49:00 +00:00
#include <QHeaderView>
#include <QMenu>
#include <QTableWidget>
#include <QToolBar>
#include <QVBoxLayout>
2017-09-27 06:53:05 +00:00
#include "Common/FileUtil.h"
#include "Common/IniFile.h"
#include "Core/ConfigManager.h"
#include "Core/Core.h"
#include "Core/PowerPC/MMU.h"
2017-09-27 06:53:05 +00:00
#include "Core/PowerPC/PowerPC.h"
2018-04-11 21:43:47 +00:00
#include "DolphinQt/Host.h"
2019-03-04 19:49:00 +00:00
#include "DolphinQt/QtUtils/ModalMessageBox.h"
2018-07-06 22:40:15 +00:00
#include "DolphinQt/Resources.h"
#include "DolphinQt/Settings.h"
2017-09-27 06:53:05 +00:00
WatchWidget::WatchWidget(QWidget* parent) : QDockWidget(parent)
{
// i18n: This kind of "watch" is used for watching emulated memory.
// It's not related to timekeeping devices.
2017-09-27 06:53:05 +00:00
setWindowTitle(tr("Watch"));
2018-04-19 09:32:00 +00:00
setObjectName(QStringLiteral("watch"));
setHidden(!Settings::Instance().IsWatchVisible() || !Settings::Instance().IsDebugModeEnabled());
2017-09-27 06:53:05 +00:00
setAllowedAreas(Qt::AllDockWidgetAreas);
CreateWidgets();
auto& settings = Settings::GetQSettings();
2017-09-27 06:53:05 +00:00
restoreGeometry(settings.value(QStringLiteral("watchwidget/geometry")).toByteArray());
// macOS: setHidden() needs to be evaluated before setFloating() for proper window presentation
// according to Settings
2017-09-27 06:53:05 +00:00
setFloating(settings.value(QStringLiteral("watchwidget/floating")).toBool());
ConnectWidgets();
connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
UpdateButtonsEnabled();
2017-09-27 06:53:05 +00:00
if (state != Core::State::Starting)
Update();
});
connect(Host::GetInstance(), &Host::UpdateDisasmDialog, this, &WatchWidget::Update);
connect(&Settings::Instance(), &Settings::WatchVisibilityChanged, this,
2017-09-27 06:53:05 +00:00
[this](bool visible) { setHidden(!visible); });
connect(&Settings::Instance(), &Settings::DebugModeToggled, this,
2017-09-27 06:53:05 +00:00
[this](bool enabled) { setHidden(!enabled || !Settings::Instance().IsWatchVisible()); });
2018-04-11 21:43:47 +00:00
connect(&Settings::Instance(), &Settings::ThemeChanged, this, &WatchWidget::UpdateIcons);
UpdateIcons();
2017-09-27 06:53:05 +00:00
}
WatchWidget::~WatchWidget()
{
auto& settings = Settings::GetQSettings();
2017-09-27 06:53:05 +00:00
settings.setValue(QStringLiteral("watchwidget/geometry"), saveGeometry());
settings.setValue(QStringLiteral("watchwidget/floating"), isFloating());
}
void WatchWidget::CreateWidgets()
{
m_toolbar = new QToolBar;
2018-08-02 19:50:23 +00:00
m_toolbar->setContentsMargins(0, 0, 0, 0);
2018-04-11 21:43:47 +00:00
m_toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
2017-09-27 06:53:05 +00:00
m_table = new QTableWidget;
m_table->setTabKeyNavigation(false);
2017-09-27 06:53:05 +00:00
2018-08-02 19:50:23 +00:00
m_table->setContentsMargins(0, 0, 0, 0);
2019-06-28 21:04:23 +00:00
m_table->setColumnCount(NUM_COLUMNS);
2017-09-27 06:53:05 +00:00
m_table->verticalHeader()->setHidden(true);
m_table->setContextMenuPolicy(Qt::CustomContextMenu);
m_table->setSelectionMode(QAbstractItemView::SingleSelection);
2018-07-09 08:02:10 +00:00
m_load = m_toolbar->addAction(tr("Load"), this, &WatchWidget::OnLoad);
m_save = m_toolbar->addAction(tr("Save"), this, &WatchWidget::OnSave);
2017-09-27 06:53:05 +00:00
m_load->setEnabled(false);
m_save->setEnabled(false);
auto* layout = new QVBoxLayout;
2018-08-02 19:50:23 +00:00
layout->setContentsMargins(2, 2, 2, 2);
layout->setSpacing(0);
2017-09-27 06:53:05 +00:00
layout->addWidget(m_toolbar);
layout->addWidget(m_table);
QWidget* widget = new QWidget;
widget->setLayout(layout);
setWidget(widget);
}
void WatchWidget::ConnectWidgets()
{
connect(m_table, &QTableWidget::customContextMenuRequested, this, &WatchWidget::ShowContextMenu);
connect(m_table, &QTableWidget::itemChanged, this, &WatchWidget::OnItemChanged);
}
2018-04-11 21:43:47 +00:00
void WatchWidget::UpdateIcons()
{
m_load->setIcon(Resources::GetScaledThemeIcon("debugger_load"));
m_save->setIcon(Resources::GetScaledThemeIcon("debugger_save"));
}
void WatchWidget::UpdateButtonsEnabled()
{
if (!isVisible())
return;
m_load->setEnabled(Core::IsRunning());
m_save->setEnabled(Core::IsRunning());
}
2017-09-27 06:53:05 +00:00
void WatchWidget::Update()
{
if (!isVisible())
return;
2017-09-27 06:53:05 +00:00
m_updating = true;
m_table->clear();
int size = static_cast<int>(PowerPC::debug_interface.GetWatches().size());
2017-09-27 06:53:05 +00:00
m_table->setRowCount(size + 1);
m_table->setHorizontalHeaderLabels(
{tr("Label"), tr("Address"), tr("Hexadecimal"),
// i18n: The base 10 numeral system. Not related to non-integer numbers
tr("Decimal"),
// i18n: Data type used in computing
2019-06-28 21:04:23 +00:00
tr("String"),
// i18n: Floating-point (non-integer) number
tr("Float")});
2017-09-27 06:53:05 +00:00
for (int i = 0; i < size; i++)
{
auto entry = PowerPC::debug_interface.GetWatch(i);
2017-09-27 06:53:05 +00:00
auto* label = new QTableWidgetItem(QString::fromStdString(entry.name));
auto* address =
new QTableWidgetItem(QStringLiteral("%1").arg(entry.address, 8, 16, QLatin1Char('0')));
auto* hex = new QTableWidgetItem;
auto* decimal = new QTableWidgetItem;
auto* string = new QTableWidgetItem;
2019-06-28 21:04:23 +00:00
auto* floatValue = new QTableWidgetItem;
std::array<QTableWidgetItem*, NUM_COLUMNS> items = {label, address, hex,
decimal, string, floatValue};
2017-09-27 06:53:05 +00:00
QBrush brush = QPalette().brush(QPalette::Text);
if (!Core::IsRunning() || !PowerPC::HostIsRAMAddress(entry.address))
brush.setColor(Qt::red);
if (Core::IsRunning())
{
if (PowerPC::HostIsRAMAddress(entry.address))
{
hex->setText(QStringLiteral("%1").arg(PowerPC::HostRead_U32(entry.address), 8, 16,
QLatin1Char('0')));
decimal->setText(QString::number(PowerPC::HostRead_U32(entry.address)));
string->setText(QString::fromStdString(PowerPC::HostGetString(entry.address, 32)));
2019-06-28 21:04:23 +00:00
floatValue->setText(QString::number(PowerPC::HostRead_F32(entry.address)));
2017-09-27 06:53:05 +00:00
}
}
address->setForeground(brush);
2019-06-28 21:04:23 +00:00
string->setFlags(Qt::ItemIsEnabled);
2017-09-27 06:53:05 +00:00
2019-06-28 21:04:23 +00:00
for (int column = 0; column < NUM_COLUMNS; column++)
2017-09-27 06:53:05 +00:00
{
2019-06-28 21:04:23 +00:00
auto* item = items[column];
2017-09-27 06:53:05 +00:00
item->setData(Qt::UserRole, i);
2019-06-28 21:04:23 +00:00
item->setData(Qt::UserRole + 1, column);
m_table->setItem(i, column, item);
2017-09-27 06:53:05 +00:00
}
}
auto* label = new QTableWidgetItem;
label->setData(Qt::UserRole, -1);
m_table->setItem(size, 0, label);
2019-06-28 21:04:23 +00:00
for (int i = 1; i < NUM_COLUMNS; i++)
2017-09-27 06:53:05 +00:00
{
auto* no_edit = new QTableWidgetItem;
no_edit->setFlags(Qt::ItemIsEnabled);
m_table->setItem(size, i, no_edit);
}
m_updating = false;
}
void WatchWidget::closeEvent(QCloseEvent*)
{
Settings::Instance().SetWatchVisible(false);
}
void WatchWidget::showEvent(QShowEvent* event)
{
UpdateButtonsEnabled();
Update();
}
2017-09-27 06:53:05 +00:00
void WatchWidget::OnLoad()
{
IniFile ini;
std::vector<std::string> watches;
2017-09-27 06:53:05 +00:00
if (!ini.Load(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini",
false))
{
return;
}
if (ini.GetLines("Watches", &watches, false))
{
PowerPC::debug_interface.ClearWatches();
PowerPC::debug_interface.LoadWatchesFromStrings(watches);
2017-09-27 06:53:05 +00:00
}
Update();
}
void WatchWidget::OnSave()
{
IniFile ini;
ini.Load(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini",
false);
ini.SetLines("Watches", PowerPC::debug_interface.SaveWatchesToStrings());
2017-09-27 06:53:05 +00:00
ini.Save(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini");
}
void WatchWidget::ShowContextMenu()
{
QMenu* menu = new QMenu(this);
2019-02-12 22:47:17 +00:00
if (!m_table->selectedItems().empty())
2017-09-27 06:53:05 +00:00
{
auto row_variant = m_table->selectedItems()[0]->data(Qt::UserRole);
if (!row_variant.isNull())
{
int row = row_variant.toInt();
if (row >= 0)
{
// i18n: This kind of "watch" is used for watching emulated memory.
// It's not related to timekeeping devices.
2018-07-09 08:02:10 +00:00
menu->addAction(tr("&Delete Watch"), this, [this, row] { DeleteWatch(row); });
menu->addAction(tr("&Add Memory Breakpoint"), this,
[this, row] { AddWatchBreakpoint(row); });
2017-09-27 06:53:05 +00:00
}
}
}
menu->addSeparator();
2018-07-09 08:02:10 +00:00
menu->addAction(tr("Update"), this, &WatchWidget::Update);
2017-09-27 06:53:05 +00:00
menu->exec(QCursor::pos());
}
void WatchWidget::OnItemChanged(QTableWidgetItem* item)
{
if (m_updating || item->data(Qt::UserRole).isNull())
return;
int row = item->data(Qt::UserRole).toInt();
int column = item->data(Qt::UserRole + 1).toInt();
if (row == -1)
{
if (!item->text().isEmpty())
{
AddWatch(item->text(), 0);
Update();
return;
}
}
else
{
switch (column)
{
// Label
case 0:
if (item->text().isEmpty())
DeleteWatch(row);
else
PowerPC::debug_interface.UpdateWatchName(row, item->text().toStdString());
2017-09-27 06:53:05 +00:00
break;
// Address
// Hexadecimal
// Decimal
case 1:
case 2:
case 3:
{
bool good;
quint32 value = item->text().toUInt(&good, column < 3 ? 16 : 10);
if (good)
{
if (column == 1)
PowerPC::debug_interface.UpdateWatchAddress(row, value);
2017-09-27 06:53:05 +00:00
else
PowerPC::HostWrite_U32(value, PowerPC::debug_interface.GetWatch(row).address);
2017-09-27 06:53:05 +00:00
}
else
{
2019-03-04 19:49:00 +00:00
ModalMessageBox::critical(this, tr("Error"), tr("Invalid input provided"));
2017-09-27 06:53:05 +00:00
}
break;
}
}
Update();
}
}
void WatchWidget::DeleteWatch(int row)
{
PowerPC::debug_interface.RemoveWatch(row);
2017-09-27 06:53:05 +00:00
Update();
}
void WatchWidget::AddWatchBreakpoint(int row)
{
emit RequestMemoryBreakpoint(PowerPC::debug_interface.GetWatch(row).address);
2017-09-27 06:53:05 +00:00
}
void WatchWidget::AddWatch(QString name, u32 addr)
{
PowerPC::debug_interface.SetWatch(addr, name.toStdString());
Update();
2017-09-27 06:53:05 +00:00
}