Browse Source
[frontend] Remove QDockWidget Wait Tree (#2949)
[frontend] Remove QDockWidget Wait Tree (#2949)
No one uses it and knows how to use it. So, remove it and replace it later with something more useful :) Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2949 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Co-authored-by: unknown <sahyno1996@gmail.com> Co-committed-by: unknown <sahyno1996@gmail.com>pull/2992/head
unknown
1 month ago
committed by
crueter
crueter
No known key found for this signature in database
GPG Key ID: 425ACD2D4830EBC6
7 changed files with 0 additions and 738 deletions
-
25dist/qt_themes/qdarkstyle/style.qss
-
48dist/qt_themes/qdarkstyle_midnight_blue/style.qss
-
2src/yuzu/CMakeLists.txt
-
434src/yuzu/debugger/wait_tree.cpp
-
188src/yuzu/debugger/wait_tree.h
-
39src/yuzu/main.cpp
-
2src/yuzu/main.h
@ -1,434 +0,0 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
|||
|
|||
// SPDX-FileCopyrightText: 2016 Citra Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <array>
|
|||
#include <fmt/ranges.h>
|
|||
|
|||
#include "yuzu/debugger/wait_tree.h"
|
|||
#include "qt_common/config/uisettings.h"
|
|||
|
|||
#include "core/arm/debug.h"
|
|||
#include "core/core.h"
|
|||
#include "core/hle/kernel/k_class_token.h"
|
|||
#include "core/hle/kernel/k_handle_table.h"
|
|||
#include "core/hle/kernel/k_process.h"
|
|||
#include "core/hle/kernel/k_readable_event.h"
|
|||
#include "core/hle/kernel/k_scheduler.h"
|
|||
#include "core/hle/kernel/k_synchronization_object.h"
|
|||
#include "core/hle/kernel/k_thread.h"
|
|||
#include "core/hle/kernel/svc_common.h"
|
|||
#include "core/hle/kernel/svc_types.h"
|
|||
#include "core/memory.h"
|
|||
|
|||
namespace { |
|||
|
|||
constexpr std::array<std::array<Qt::GlobalColor, 2>, 10> WaitTreeColors{{ |
|||
{Qt::GlobalColor::darkGreen, Qt::GlobalColor::green}, |
|||
{Qt::GlobalColor::darkBlue, Qt::GlobalColor::cyan}, |
|||
{Qt::GlobalColor::lightGray, Qt::GlobalColor::lightGray}, |
|||
{Qt::GlobalColor::lightGray, Qt::GlobalColor::lightGray}, |
|||
{Qt::GlobalColor::darkRed, Qt::GlobalColor::red}, |
|||
{Qt::GlobalColor::darkYellow, Qt::GlobalColor::yellow}, |
|||
{Qt::GlobalColor::red, Qt::GlobalColor::red}, |
|||
{Qt::GlobalColor::darkCyan, Qt::GlobalColor::cyan}, |
|||
{Qt::GlobalColor::gray, Qt::GlobalColor::gray}, |
|||
}}; |
|||
|
|||
bool IsDarkTheme() { |
|||
const auto& theme = UISettings::values.theme; |
|||
return theme == std::string("qdarkstyle") || theme == std::string("qdarkstyle_midnight_blue") || |
|||
theme == std::string("colorful_dark") || theme == std::string("colorful_midnight_blue"); |
|||
} |
|||
|
|||
} // namespace
|
|||
|
|||
WaitTreeItem::WaitTreeItem() = default; |
|||
WaitTreeItem::~WaitTreeItem() = default; |
|||
|
|||
QColor WaitTreeItem::GetColor() const { |
|||
if (IsDarkTheme()) { |
|||
return QColor(Qt::GlobalColor::white); |
|||
} else { |
|||
return QColor(Qt::GlobalColor::black); |
|||
} |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeItem::GetChildren() const { |
|||
return {}; |
|||
} |
|||
|
|||
void WaitTreeItem::Expand() { |
|||
if (IsExpandable() && !expanded) { |
|||
children = GetChildren(); |
|||
for (std::size_t i = 0; i < children.size(); ++i) { |
|||
children[i]->parent = this; |
|||
children[i]->row = i; |
|||
} |
|||
expanded = true; |
|||
} |
|||
} |
|||
|
|||
WaitTreeItem* WaitTreeItem::Parent() const { |
|||
return parent; |
|||
} |
|||
|
|||
const std::vector<std::unique_ptr<WaitTreeItem>>& WaitTreeItem::Children() const { |
|||
return children; |
|||
} |
|||
|
|||
bool WaitTreeItem::IsExpandable() const { |
|||
return false; |
|||
} |
|||
|
|||
std::size_t WaitTreeItem::Row() const { |
|||
return row; |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeThread>> WaitTreeItem::MakeThreadItemList( |
|||
Core::System& system) { |
|||
std::vector<std::unique_ptr<WaitTreeThread>> item_list; |
|||
std::size_t row = 0; |
|||
auto add_threads = [&](const std::vector<Kernel::KThread*>& threads) { |
|||
for (std::size_t i = 0; i < threads.size(); ++i) { |
|||
if (threads[i]->GetThreadType() == Kernel::ThreadType::User) { |
|||
item_list.push_back(std::make_unique<WaitTreeThread>(*threads[i], system)); |
|||
item_list.back()->row = row; |
|||
} |
|||
++row; |
|||
} |
|||
}; |
|||
|
|||
add_threads(system.GlobalSchedulerContext().GetThreadList()); |
|||
|
|||
return item_list; |
|||
} |
|||
|
|||
WaitTreeText::WaitTreeText(QString t) : text(std::move(t)) {} |
|||
WaitTreeText::~WaitTreeText() = default; |
|||
|
|||
QString WaitTreeText::GetText() const { |
|||
return text; |
|||
} |
|||
|
|||
WaitTreeCallstack::WaitTreeCallstack(const Kernel::KThread& thread_, Core::System& system_) |
|||
: thread{thread_}, system{system_} {} |
|||
WaitTreeCallstack::~WaitTreeCallstack() = default; |
|||
|
|||
QString WaitTreeCallstack::GetText() const { |
|||
return tr("Call stack"); |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeCallstack::GetChildren() const { |
|||
std::vector<std::unique_ptr<WaitTreeItem>> list; |
|||
|
|||
if (thread.GetThreadType() != Kernel::ThreadType::User) { |
|||
return list; |
|||
} |
|||
|
|||
if (thread.GetOwnerProcess() == nullptr || !thread.GetOwnerProcess()->Is64Bit()) { |
|||
return list; |
|||
} |
|||
|
|||
auto backtrace = Core::GetBacktraceFromContext(thread.GetOwnerProcess(), thread.GetContext()); |
|||
|
|||
for (auto& entry : backtrace) { |
|||
std::string s = fmt::format("{:20}{:016X} {:016X} {:016X} {}", entry.module, entry.address, |
|||
entry.original_address, entry.offset, entry.name); |
|||
list.push_back(std::make_unique<WaitTreeText>(QString::fromStdString(s))); |
|||
} |
|||
|
|||
return list; |
|||
} |
|||
|
|||
WaitTreeSynchronizationObject::WaitTreeSynchronizationObject( |
|||
const Kernel::KSynchronizationObject& object_, Core::System& system_) |
|||
: object{object_}, system{system_} {} |
|||
WaitTreeSynchronizationObject::~WaitTreeSynchronizationObject() = default; |
|||
|
|||
WaitTreeExpandableItem::WaitTreeExpandableItem() = default; |
|||
WaitTreeExpandableItem::~WaitTreeExpandableItem() = default; |
|||
|
|||
bool WaitTreeExpandableItem::IsExpandable() const { |
|||
return true; |
|||
} |
|||
|
|||
QString WaitTreeSynchronizationObject::GetText() const { |
|||
return tr("[%1] %2") |
|||
.arg(object.GetId()) |
|||
.arg(QString::fromStdString(object.GetTypeObj().GetName())); |
|||
} |
|||
|
|||
std::unique_ptr<WaitTreeSynchronizationObject> WaitTreeSynchronizationObject::make( |
|||
const Kernel::KSynchronizationObject& object, Core::System& system) { |
|||
const auto type = |
|||
static_cast<Kernel::KClassTokenGenerator::ObjectType>(object.GetTypeObj().GetClassToken()); |
|||
switch (type) { |
|||
case Kernel::KClassTokenGenerator::ObjectType::KReadableEvent: |
|||
return std::make_unique<WaitTreeEvent>(static_cast<const Kernel::KReadableEvent&>(object), |
|||
system); |
|||
case Kernel::KClassTokenGenerator::ObjectType::KThread: |
|||
return std::make_unique<WaitTreeThread>(static_cast<const Kernel::KThread&>(object), |
|||
system); |
|||
default: |
|||
return std::make_unique<WaitTreeSynchronizationObject>(object, system); |
|||
} |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeSynchronizationObject::GetChildren() const { |
|||
std::vector<std::unique_ptr<WaitTreeItem>> list; |
|||
|
|||
auto threads = object.GetWaitingThreadsForDebugging(); |
|||
if (threads.empty()) { |
|||
list.push_back(std::make_unique<WaitTreeText>(tr("waited by no thread"))); |
|||
} else { |
|||
list.push_back(std::make_unique<WaitTreeThreadList>(std::move(threads), system)); |
|||
} |
|||
|
|||
return list; |
|||
} |
|||
|
|||
WaitTreeThread::WaitTreeThread(const Kernel::KThread& thread, Core::System& system_) |
|||
: WaitTreeSynchronizationObject(thread, system_), system{system_} {} |
|||
WaitTreeThread::~WaitTreeThread() = default; |
|||
|
|||
QString WaitTreeThread::GetText() const { |
|||
const auto& thread = static_cast<const Kernel::KThread&>(object); |
|||
QString status; |
|||
switch (thread.GetState()) { |
|||
case Kernel::ThreadState::Runnable: |
|||
if (!thread.IsSuspended()) { |
|||
status = tr("runnable"); |
|||
} else { |
|||
status = tr("paused"); |
|||
} |
|||
break; |
|||
case Kernel::ThreadState::Waiting: |
|||
switch (thread.GetWaitReasonForDebugging()) { |
|||
case Kernel::ThreadWaitReasonForDebugging::Sleep: |
|||
status = tr("sleeping"); |
|||
break; |
|||
case Kernel::ThreadWaitReasonForDebugging::IPC: |
|||
status = tr("waiting for IPC reply"); |
|||
break; |
|||
case Kernel::ThreadWaitReasonForDebugging::Synchronization: |
|||
status = tr("waiting for objects"); |
|||
break; |
|||
case Kernel::ThreadWaitReasonForDebugging::ConditionVar: |
|||
status = tr("waiting for condition variable"); |
|||
break; |
|||
case Kernel::ThreadWaitReasonForDebugging::Arbitration: |
|||
status = tr("waiting for address arbiter"); |
|||
break; |
|||
case Kernel::ThreadWaitReasonForDebugging::Suspended: |
|||
status = tr("waiting for suspend resume"); |
|||
break; |
|||
default: |
|||
status = tr("waiting"); |
|||
break; |
|||
} |
|||
break; |
|||
case Kernel::ThreadState::Initialized: |
|||
status = tr("initialized"); |
|||
break; |
|||
case Kernel::ThreadState::Terminated: |
|||
status = tr("terminated"); |
|||
break; |
|||
default: |
|||
status = tr("unknown"); |
|||
break; |
|||
} |
|||
|
|||
const auto& context = thread.GetContext(); |
|||
const QString pc_info = tr(" PC = 0x%1 LR = 0x%2") |
|||
.arg(context.pc, 8, 16, QLatin1Char{'0'}) |
|||
.arg(context.lr, 8, 16, QLatin1Char{'0'}); |
|||
return QStringLiteral("%1%2 (%3) ") |
|||
.arg(WaitTreeSynchronizationObject::GetText(), pc_info, status); |
|||
} |
|||
|
|||
QColor WaitTreeThread::GetColor() const { |
|||
const std::size_t color_index = IsDarkTheme() ? 1 : 0; |
|||
|
|||
const auto& thread = static_cast<const Kernel::KThread&>(object); |
|||
switch (thread.GetState()) { |
|||
case Kernel::ThreadState::Runnable: |
|||
if (!thread.IsSuspended()) { |
|||
return QColor(WaitTreeColors[0][color_index]); |
|||
} else { |
|||
return QColor(WaitTreeColors[2][color_index]); |
|||
} |
|||
case Kernel::ThreadState::Waiting: |
|||
switch (thread.GetWaitReasonForDebugging()) { |
|||
case Kernel::ThreadWaitReasonForDebugging::IPC: |
|||
return QColor(WaitTreeColors[4][color_index]); |
|||
case Kernel::ThreadWaitReasonForDebugging::Sleep: |
|||
return QColor(WaitTreeColors[5][color_index]); |
|||
case Kernel::ThreadWaitReasonForDebugging::Synchronization: |
|||
case Kernel::ThreadWaitReasonForDebugging::ConditionVar: |
|||
case Kernel::ThreadWaitReasonForDebugging::Arbitration: |
|||
case Kernel::ThreadWaitReasonForDebugging::Suspended: |
|||
return QColor(WaitTreeColors[6][color_index]); |
|||
break; |
|||
default: |
|||
return QColor(WaitTreeColors[3][color_index]); |
|||
} |
|||
case Kernel::ThreadState::Initialized: |
|||
return QColor(WaitTreeColors[7][color_index]); |
|||
case Kernel::ThreadState::Terminated: |
|||
return QColor(WaitTreeColors[8][color_index]); |
|||
default: |
|||
return WaitTreeItem::GetColor(); |
|||
} |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const { |
|||
std::vector<std::unique_ptr<WaitTreeItem>> list(WaitTreeSynchronizationObject::GetChildren()); |
|||
|
|||
const auto& thread = static_cast<const Kernel::KThread&>(object); |
|||
|
|||
QString processor; |
|||
switch (thread.GetActiveCore()) { |
|||
case Kernel::Svc::IdealCoreUseProcessValue: |
|||
processor = tr("ideal"); |
|||
break; |
|||
default: |
|||
processor = tr("core %1").arg(thread.GetActiveCore()); |
|||
break; |
|||
} |
|||
|
|||
list.push_back(std::make_unique<WaitTreeText>(tr("processor = %1").arg(processor))); |
|||
list.push_back(std::make_unique<WaitTreeText>( |
|||
tr("affinity mask = %1").arg(thread.GetAffinityMask().GetAffinityMask()))); |
|||
list.push_back(std::make_unique<WaitTreeText>(tr("thread id = %1").arg(thread.GetThreadId()))); |
|||
list.push_back(std::make_unique<WaitTreeText>(tr("priority = %1(current) / %2(normal)") |
|||
.arg(thread.GetPriority()) |
|||
.arg(thread.GetBasePriority()))); |
|||
list.push_back(std::make_unique<WaitTreeText>( |
|||
tr("last running ticks = %1").arg(thread.GetLastScheduledTick()))); |
|||
|
|||
list.push_back(std::make_unique<WaitTreeCallstack>(thread, system)); |
|||
|
|||
return list; |
|||
} |
|||
|
|||
WaitTreeEvent::WaitTreeEvent(const Kernel::KReadableEvent& object_, Core::System& system_) |
|||
: WaitTreeSynchronizationObject(object_, system_) {} |
|||
WaitTreeEvent::~WaitTreeEvent() = default; |
|||
|
|||
WaitTreeThreadList::WaitTreeThreadList(std::vector<Kernel::KThread*>&& list, Core::System& system_) |
|||
: thread_list(std::move(list)), system{system_} {} |
|||
WaitTreeThreadList::~WaitTreeThreadList() = default; |
|||
|
|||
QString WaitTreeThreadList::GetText() const { |
|||
return tr("waited by thread"); |
|||
} |
|||
|
|||
std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThreadList::GetChildren() const { |
|||
std::vector<std::unique_ptr<WaitTreeItem>> list(thread_list.size()); |
|||
std::transform(thread_list.begin(), thread_list.end(), list.begin(), |
|||
[this](const auto& t) { return std::make_unique<WaitTreeThread>(*t, system); }); |
|||
return list; |
|||
} |
|||
|
|||
WaitTreeModel::WaitTreeModel(Core::System& system_, QObject* parent) |
|||
: QAbstractItemModel(parent), system{system_} {} |
|||
WaitTreeModel::~WaitTreeModel() = default; |
|||
|
|||
QModelIndex WaitTreeModel::index(int row, int column, const QModelIndex& parent) const { |
|||
if (!hasIndex(row, column, parent)) |
|||
return {}; |
|||
|
|||
if (parent.isValid()) { |
|||
WaitTreeItem* parent_item = static_cast<WaitTreeItem*>(parent.internalPointer()); |
|||
parent_item->Expand(); |
|||
return createIndex(row, column, parent_item->Children()[row].get()); |
|||
} |
|||
|
|||
return createIndex(row, column, thread_items[row].get()); |
|||
} |
|||
|
|||
QModelIndex WaitTreeModel::parent(const QModelIndex& index) const { |
|||
if (!index.isValid()) |
|||
return {}; |
|||
|
|||
WaitTreeItem* parent_item = static_cast<WaitTreeItem*>(index.internalPointer())->Parent(); |
|||
if (!parent_item) { |
|||
return QModelIndex(); |
|||
} |
|||
return createIndex(static_cast<int>(parent_item->Row()), 0, parent_item); |
|||
} |
|||
|
|||
int WaitTreeModel::rowCount(const QModelIndex& parent) const { |
|||
if (!parent.isValid()) |
|||
return static_cast<int>(thread_items.size()); |
|||
|
|||
WaitTreeItem* parent_item = static_cast<WaitTreeItem*>(parent.internalPointer()); |
|||
parent_item->Expand(); |
|||
return static_cast<int>(parent_item->Children().size()); |
|||
} |
|||
|
|||
int WaitTreeModel::columnCount(const QModelIndex&) const { |
|||
return 1; |
|||
} |
|||
|
|||
QVariant WaitTreeModel::data(const QModelIndex& index, int role) const { |
|||
if (!index.isValid()) |
|||
return {}; |
|||
|
|||
switch (role) { |
|||
case Qt::DisplayRole: |
|||
return static_cast<WaitTreeItem*>(index.internalPointer())->GetText(); |
|||
case Qt::ForegroundRole: |
|||
return static_cast<WaitTreeItem*>(index.internalPointer())->GetColor(); |
|||
default: |
|||
return {}; |
|||
} |
|||
} |
|||
|
|||
void WaitTreeModel::ClearItems() { |
|||
thread_items.clear(); |
|||
} |
|||
|
|||
void WaitTreeModel::InitItems() { |
|||
thread_items = WaitTreeItem::MakeThreadItemList(system); |
|||
} |
|||
|
|||
WaitTreeWidget::WaitTreeWidget(Core::System& system_, QWidget* parent) |
|||
: QDockWidget(tr("&Wait Tree"), parent), system{system_} { |
|||
setObjectName(QStringLiteral("WaitTreeWidget")); |
|||
view = new QTreeView(this); |
|||
view->setHeaderHidden(true); |
|||
setWidget(view); |
|||
setEnabled(false); |
|||
} |
|||
|
|||
WaitTreeWidget::~WaitTreeWidget() = default; |
|||
|
|||
void WaitTreeWidget::OnDebugModeEntered() { |
|||
if (!system.IsPoweredOn()) |
|||
return; |
|||
model->InitItems(); |
|||
view->setModel(model); |
|||
setEnabled(true); |
|||
} |
|||
|
|||
void WaitTreeWidget::OnDebugModeLeft() { |
|||
setEnabled(false); |
|||
view->setModel(nullptr); |
|||
model->ClearItems(); |
|||
} |
|||
|
|||
void WaitTreeWidget::OnEmulationStarting(EmuThread* emu_thread) { |
|||
model = new WaitTreeModel(system, this); |
|||
view->setModel(model); |
|||
setEnabled(false); |
|||
} |
|||
|
|||
void WaitTreeWidget::OnEmulationStopping() { |
|||
view->setModel(nullptr); |
|||
delete model; |
|||
setEnabled(false); |
|||
} |
|||
@ -1,188 +0,0 @@ |
|||
// SPDX-FileCopyrightText: 2016 Citra Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <cstddef> |
|||
#include <memory> |
|||
#include <vector> |
|||
|
|||
#include <QDockWidget> |
|||
#include <QTreeView> |
|||
|
|||
#include "common/common_types.h" |
|||
#include "core/hle/kernel/k_auto_object.h" |
|||
#include "core/hle/kernel/svc_common.h" |
|||
|
|||
class EmuThread; |
|||
|
|||
namespace Core { |
|||
class System; |
|||
} |
|||
|
|||
namespace Kernel { |
|||
class KHandleTable; |
|||
class KReadableEvent; |
|||
class KSynchronizationObject; |
|||
class KThread; |
|||
} // namespace Kernel |
|||
|
|||
class WaitTreeThread; |
|||
|
|||
class WaitTreeItem : public QObject { |
|||
Q_OBJECT |
|||
public: |
|||
WaitTreeItem(); |
|||
~WaitTreeItem() override; |
|||
|
|||
virtual bool IsExpandable() const; |
|||
virtual std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const; |
|||
virtual QString GetText() const = 0; |
|||
virtual QColor GetColor() const; |
|||
|
|||
void Expand(); |
|||
WaitTreeItem* Parent() const; |
|||
const std::vector<std::unique_ptr<WaitTreeItem>>& Children() const; |
|||
std::size_t Row() const; |
|||
static std::vector<std::unique_ptr<WaitTreeThread>> MakeThreadItemList(Core::System& system); |
|||
|
|||
private: |
|||
std::size_t row; |
|||
bool expanded = false; |
|||
WaitTreeItem* parent = nullptr; |
|||
std::vector<std::unique_ptr<WaitTreeItem>> children; |
|||
}; |
|||
|
|||
class WaitTreeText : public WaitTreeItem { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeText(QString text); |
|||
~WaitTreeText() override; |
|||
|
|||
QString GetText() const override; |
|||
|
|||
private: |
|||
QString text; |
|||
}; |
|||
|
|||
class WaitTreeExpandableItem : public WaitTreeItem { |
|||
Q_OBJECT |
|||
public: |
|||
WaitTreeExpandableItem(); |
|||
~WaitTreeExpandableItem() override; |
|||
|
|||
bool IsExpandable() const override; |
|||
}; |
|||
|
|||
class WaitTreeCallstack : public WaitTreeExpandableItem { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeCallstack(const Kernel::KThread& thread_, Core::System& system_); |
|||
~WaitTreeCallstack() override; |
|||
|
|||
QString GetText() const override; |
|||
std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override; |
|||
|
|||
private: |
|||
const Kernel::KThread& thread; |
|||
|
|||
Core::System& system; |
|||
}; |
|||
|
|||
class WaitTreeSynchronizationObject : public WaitTreeExpandableItem { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeSynchronizationObject(const Kernel::KSynchronizationObject& object_, |
|||
Core::System& system_); |
|||
~WaitTreeSynchronizationObject() override; |
|||
|
|||
static std::unique_ptr<WaitTreeSynchronizationObject> make( |
|||
const Kernel::KSynchronizationObject& object, Core::System& system); |
|||
QString GetText() const override; |
|||
std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override; |
|||
|
|||
protected: |
|||
const Kernel::KSynchronizationObject& object; |
|||
|
|||
private: |
|||
Core::System& system; |
|||
}; |
|||
|
|||
class WaitTreeThread : public WaitTreeSynchronizationObject { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeThread(const Kernel::KThread& thread, Core::System& system_); |
|||
~WaitTreeThread() override; |
|||
|
|||
QString GetText() const override; |
|||
QColor GetColor() const override; |
|||
std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override; |
|||
|
|||
private: |
|||
Core::System& system; |
|||
}; |
|||
|
|||
class WaitTreeEvent : public WaitTreeSynchronizationObject { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeEvent(const Kernel::KReadableEvent& object_, Core::System& system_); |
|||
~WaitTreeEvent() override; |
|||
}; |
|||
|
|||
class WaitTreeThreadList : public WaitTreeExpandableItem { |
|||
Q_OBJECT |
|||
public: |
|||
explicit WaitTreeThreadList(std::vector<Kernel::KThread*>&& list, Core::System& system_); |
|||
~WaitTreeThreadList() override; |
|||
|
|||
QString GetText() const override; |
|||
std::vector<std::unique_ptr<WaitTreeItem>> GetChildren() const override; |
|||
|
|||
private: |
|||
std::vector<Kernel::KThread*> thread_list; |
|||
|
|||
Core::System& system; |
|||
}; |
|||
|
|||
class WaitTreeModel : public QAbstractItemModel { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit WaitTreeModel(Core::System& system_, QObject* parent = nullptr); |
|||
~WaitTreeModel() override; |
|||
|
|||
QVariant data(const QModelIndex& index, int role) const override; |
|||
QModelIndex index(int row, int column, const QModelIndex& parent) const override; |
|||
QModelIndex parent(const QModelIndex& index) const override; |
|||
int rowCount(const QModelIndex& parent) const override; |
|||
int columnCount(const QModelIndex& parent) const override; |
|||
|
|||
void ClearItems(); |
|||
void InitItems(); |
|||
|
|||
private: |
|||
std::vector<std::unique_ptr<WaitTreeThread>> thread_items; |
|||
|
|||
Core::System& system; |
|||
}; |
|||
|
|||
class WaitTreeWidget : public QDockWidget { |
|||
Q_OBJECT |
|||
|
|||
public: |
|||
explicit WaitTreeWidget(Core::System& system_, QWidget* parent = nullptr); |
|||
~WaitTreeWidget() override; |
|||
|
|||
public slots: |
|||
void OnDebugModeEntered(); |
|||
void OnDebugModeLeft(); |
|||
|
|||
void OnEmulationStarting(EmuThread* emu_thread); |
|||
void OnEmulationStopping(); |
|||
|
|||
private: |
|||
QTreeView* view; |
|||
WaitTreeModel* model; |
|||
|
|||
Core::System& system; |
|||
}; |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue