Apply CoreConsumer to classes using setController()

Author: ahigerd

src/platform/qt/AssetTile.cpp

@@ -45,7 +45,7 @@ int AssetTile::customLocation(const QString&) {
 	return layout()->indexOf(m_ui.line);
 }
 
-void AssetTile::setController(std::shared_ptr<CoreController> controller) {
+void AssetTile::onCoreAttached(std::shared_ptr<CoreController> controller) {
 	m_cacheSet = controller->graphicCaches();
 	switch (controller->platform()) {
 #ifdef M_CORE_GBA

src/platform/qt/AssetTile.h

@@ -5,6 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #pragma once
 
+#include "CorePointer.h"
 #include "ui_AssetTile.h"
 
 #include <memory>
@@ -15,12 +16,11 @@ namespace QGBA {
 
 class CoreController;
 
-class AssetTile : public AssetInfo {
+class AssetTile : public AssetInfo, public CoreConsumer {
 Q_OBJECT
 
 public:
 	AssetTile(QWidget* parent = nullptr);
-	void setController(std::shared_ptr<CoreController>);
 	QImage activeTile() const { return m_activeTile; }
 
 public slots:
@@ -35,6 +35,8 @@ public slots:
 	int customLocation(const QString& id = {}) override;
 
 private:
+	void onCoreAttached(std::shared_ptr<CoreController>);
+
 	Ui::AssetTile m_ui;
 
 	mCacheSet* m_cacheSet;

src/platform/qt/AssetView.cpp

@@ -6,6 +6,7 @@
 #include "AssetView.h"
 
 #include "CoreController.h"
+#include "CorePointerSource.h"
 
 #include <QTimer>
 
@@ -21,18 +22,18 @@
 
 using namespace QGBA;
 
-AssetView::AssetView(std::shared_ptr<CoreController> controller, QWidget* parent)
+AssetView::AssetView(CorePointerSource* controller, QWidget* parent)
 	: QWidget(parent)
-	, m_cacheSet(controller->graphicCaches())
-	, m_controller(controller)
+	, CoreConsumer(controller)
+	, m_cacheSet(m_controller->graphicCaches())
 {
 	m_updateTimer.setSingleShot(true);
 	m_updateTimer.setInterval(1);
 	connect(&m_updateTimer, &QTimer::timeout, this, static_cast<void(AssetView::*)()>(&AssetView::updateTiles));
 
-	connect(controller.get(), &CoreController::frameAvailable, &m_updateTimer,
+	connect(m_controller.get(), &CoreController::frameAvailable, &m_updateTimer,
 	        static_cast<void(QTimer::*)()>(&QTimer::start));
-	connect(controller.get(), &CoreController::stopping, &m_updateTimer, &QTimer::stop);
+	connect(m_controller.get(), &CoreController::stopping, &m_updateTimer, &QTimer::stop);
 }
 
 void AssetView::updateTiles() {

src/platform/qt/AssetView.h

@@ -13,25 +13,26 @@
 
 #include <memory>
 
+#include "CorePointer.h"
+
 struct mMapCacheEntry;
 
 namespace QGBA {
 
 class CoreController;
 
-class AssetView : public QWidget {
+class AssetView : public QWidget, public CoreConsumer {
 Q_OBJECT
 
 public:
-	AssetView(std::shared_ptr<CoreController> controller, QWidget* parent = nullptr);
+	AssetView(CorePointerSource* controller, QWidget* parent = nullptr);
 
 protected slots:
 	void updateTiles();
 	void updateTiles(bool force);
 
 protected:
 	mCacheSet* const m_cacheSet;
-	std::shared_ptr<CoreController> m_controller;
 
 	struct ObjInfo {
 		unsigned tile;

src/platform/qt/DebuggerConsoleController.cpp

@@ -35,7 +35,7 @@ DebuggerConsoleController::DebuggerConsoleController(QObject* parent)
 }
 
 void DebuggerConsoleController::enterLine(const QString& line) {
-	CoreController::Interrupter interrupter(m_gameController);
+	CoreController::Interrupter interrupter(m_controller);
 	QMutexLocker lock(&m_mutex);
 	m_lines.append(line);
 	if (m_cliDebugger.d.p && m_cliDebugger.d.p->state == DEBUGGER_RUNNING) {
@@ -46,7 +46,7 @@ void DebuggerConsoleController::enterLine(const QString& line) {
 
 void DebuggerConsoleController::detach() {
 	{
-		CoreController::Interrupter interrupter(m_gameController);
+		CoreController::Interrupter interrupter(m_controller);
 		QMutexLocker lock(&m_mutex);
 		if (m_cliDebugger.d.p && m_cliDebugger.d.p->state != DEBUGGER_SHUTDOWN) {
 			m_lines.append(QString());
@@ -58,9 +58,9 @@ void DebuggerConsoleController::detach() {
 }
 
 void DebuggerConsoleController::attachInternal() {
-	CoreController::Interrupter interrupter(m_gameController);
+	CoreController::Interrupter interrupter(m_controller);
 	QMutexLocker lock(&m_mutex);
-	mCore* core = m_gameController->thread()->core;
+	mCore* core = m_controller->thread()->core;
 	CLIDebuggerAttachBackend(&m_cliDebugger, &m_backend);
 	CLIDebuggerAttachSystem(&m_cliDebugger, core->cliDebuggerSystem(core));
 }
@@ -123,7 +123,7 @@ void DebuggerConsoleController::lineAppend(struct CLIDebuggerBackend* be, const
 const char* DebuggerConsoleController::historyLast(struct CLIDebuggerBackend* be, size_t* len) {
 	Backend* consoleBe = reinterpret_cast<Backend*>(be);
 	DebuggerConsoleController* self = consoleBe->self;
-	CoreController::Interrupter interrupter(self->m_gameController);
+	CoreController::Interrupter interrupter(self->m_controller);
 	QMutexLocker lock(&self->m_mutex);
 	if (self->m_history.isEmpty()) {
 		return "i";
@@ -136,7 +136,7 @@ const char* DebuggerConsoleController::historyLast(struct CLIDebuggerBackend* be
 void DebuggerConsoleController::historyAppend(struct CLIDebuggerBackend* be, const char* line) {
 	Backend* consoleBe = reinterpret_cast<Backend*>(be);
 	DebuggerConsoleController* self = consoleBe->self;
-	CoreController::Interrupter interrupter(self->m_gameController);
+	CoreController::Interrupter interrupter(self->m_controller);
 	QMutexLocker lock(&self->m_mutex);
 	self->m_history.append(QString::fromUtf8(line));
 }

src/platform/qt/DebuggerController.cpp

@@ -16,36 +16,30 @@ DebuggerController::DebuggerController(mDebuggerModule* debugger, QObject* paren
 }
 
 bool DebuggerController::isAttached() {
-	if (!m_gameController) {
+	if (!m_controller) {
 		return false;
 	}
-	return m_gameController->debugger() == m_debugger->p;
+	return m_controller->debugger() == m_debugger->p;
 }
 
-void DebuggerController::setController(std::shared_ptr<CoreController> controller) {
-	if (m_gameController && controller != m_gameController) {
-		m_gameController->disconnect(this);
-		detach();
-	}
-	m_gameController = controller;
-	if (controller) {
-		connect(m_gameController.get(), &CoreController::stopping, [this]() {
-			setController(nullptr);
-		});
-		if (m_autoattach) {
-			m_autoattach = false;
-			attach();
-		}
+void DebuggerController::onCoreDetached(std::shared_ptr<CoreController>) {
+	detach();
+}
+
+void DebuggerController::onCoreAttached(std::shared_ptr<CoreController>) {
+	if (m_autoattach) {
+		m_autoattach = false;
+		attach();
 	}
 }
 
 void DebuggerController::attach() {
 	if (isAttached()) {
 		return;
 	}
-	if (m_gameController) {
+	if (m_controller) {
 		attachInternal();
-		m_gameController->attachDebuggerModule(m_debugger);
+		m_controller->attachDebuggerModule(m_debugger);
 	} else {
 		m_autoattach = true;
 	}
@@ -55,10 +49,10 @@ void DebuggerController::detach() {
 	if (!isAttached()) {
 		return;
 	}
-	if (m_gameController) {
-		CoreController::Interrupter interrupter(m_gameController);
+	if (m_controller) {
+		CoreController::Interrupter interrupter(m_controller);
 		shutdownInternal();
-		m_gameController->detachDebuggerModule(m_debugger);
+		m_controller->detachDebuggerModule(m_debugger);
 	} else {
 		m_autoattach = false;
 	}
@@ -68,7 +62,7 @@ void DebuggerController::breakInto() {
 	if (!isAttached()) {
 		return;
 	}
-	CoreController::Interrupter interrupter(m_gameController);
+	CoreController::Interrupter interrupter(m_controller);
 	mDebuggerEnter(m_debugger->p, DEBUGGER_ENTER_MANUAL, 0);
 }
 
@@ -77,7 +71,7 @@ void DebuggerController::shutdown() {
 	if (!isAttached()) {
 		return;
 	}
-	CoreController::Interrupter interrupter(m_gameController);
+	CoreController::Interrupter interrupter(m_controller);
 	shutdownInternal();
 }
 

src/platform/qt/DebuggerController.h

@@ -9,21 +9,20 @@
 
 #include <memory>
 
+#include "CorePointer.h"
+
 struct mDebuggerModule;
 
 namespace QGBA {
 
-class CoreController;
-
-class DebuggerController : public QObject {
+class DebuggerController : public QObject, public CoreConsumer {
 Q_OBJECT
 
 public:
 	DebuggerController(mDebuggerModule* debugger, QObject* parent = nullptr);
 
 public:
 	bool isAttached();
-	void setController(std::shared_ptr<CoreController>);
 
 public slots:
 	virtual void attach();
@@ -36,9 +35,10 @@ public slots:
 	virtual void shutdownInternal();
 
 	mDebuggerModule* const m_debugger;
-	std::shared_ptr<CoreController> m_gameController;
 
 private:
+	void onCoreDetached(std::shared_ptr<CoreController>);
+	void onCoreAttached(std::shared_ptr<CoreController>);
 	bool m_autoattach = false;
 };
 

src/platform/qt/FrameView.cpp

@@ -30,8 +30,8 @@
 
 using namespace QGBA;
 
-FrameView::FrameView(std::shared_ptr<CoreController> controller, QWidget* parent)
-	: AssetView(std::move(controller), parent)
+FrameView::FrameView(CorePointerSource* controller, QWidget* parent)
+	: AssetView(controller, parent)
 {
 	m_ui.setupUi(this);
 

src/platform/qt/FrameView.h

@@ -32,7 +32,7 @@ class FrameView : public AssetView {
 Q_OBJECT
 
 public:
-	FrameView(std::shared_ptr<CoreController> controller, QWidget* parent = nullptr);
+	FrameView(CorePointerSource* controller, QWidget* parent = nullptr);
 	~FrameView();
 
 public slots:

src/platform/qt/GIFView.cpp

@@ -15,8 +15,9 @@
 
 using namespace QGBA;
 
-GIFView::GIFView(std::shared_ptr<CoreController> controller, QWidget* parent)
+GIFView::GIFView(CorePointerSource* controller, QWidget* parent)
 	: QWidget(parent)
+	, CoreConsumer(controller)
 {
 	m_ui.setupUi(this);
 
@@ -31,15 +32,13 @@ GIFView::GIFView(std::shared_ptr<CoreController> controller, QWidget* parent)
 
 	FFmpegEncoderInit(&m_encoder);
 	FFmpegEncoderSetAudio(&m_encoder, nullptr, 0);
-
-	setController(controller);
 }
 
 GIFView::~GIFView() {
 	stopRecording();
 }
 
-void GIFView::setController(std::shared_ptr<CoreController> controller) {
+void GIFView::onCoreAttached(std::shared_ptr<CoreController> controller) {
 	connect(controller.get(), &CoreController::stopping, this, &GIFView::stopRecording);
 	connect(this, &GIFView::recordingStarted, controller.get(), &CoreController::setAVStream);
 	connect(this, &GIFView::recordingStopped, controller.get(), &CoreController::clearAVStream, Qt::DirectConnection);