Separation of the controls dock from the main window

UI/basic-controls.cpp

@@ -0,0 +1,329 @@
+#include "basic-controls.hpp"
+
+#include "window-basic-main.hpp"
+
+OBSBasicControls::OBSBasicControls(OBSBasic *main)
+	: QFrame(nullptr),
+	  ui(new Ui::OBSBasicControls)
+{
+	/* Create UI elements */
+	ui->setupUi(this);
+
+	streamButtonMenu.reset(new QMenu());
+	startStreamAction =
+		streamButtonMenu->addAction(QTStr("Basic.Main.StartStreaming"));
+	stopStreamAction =
+		streamButtonMenu->addAction(QTStr("Basic.Main.StopStreaming"));
+	QAction *forceStopStreamAction = streamButtonMenu->addAction(
+		QTStr("Basic.Main.ForceStopStreaming"));
+
+	/* Transfer buttons signals as OBSBasicControls signals */
+	connect(
+		ui->streamButton, &QPushButton::clicked, this,
+		[this]() { emit this->StreamButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->broadcastButton, &QPushButton::clicked, this,
+		[this]() { emit this->BroadcastButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->recordButton, &QPushButton::clicked, this,
+		[this]() { emit this->RecordButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->pauseRecordButton, &QPushButton::clicked, this,
+		[this]() { emit this->PauseRecordButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->replayBufferButton, &QPushButton::clicked, this,
+		[this]() { emit this->ReplayBufferButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->saveReplayButton, &QPushButton::clicked, this,
+		[this]() { emit this->SaveReplayBufferButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->virtualCamButton, &QPushButton::clicked, this,
+		[this]() { emit this->VirtualCamButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->virtualCamConfigButton, &QPushButton::clicked, this,
+		[this]() { emit this->VirtualCamConfigButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->modeSwitch, &QPushButton::clicked, this,
+		[this]() { emit this->StudioModeButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->settingsButton, &QPushButton::clicked, this,
+		[this]() { emit this->SettingsButtonClicked(); },
+		Qt::DirectConnection);
+	connect(
+		ui->exitButton, &QPushButton::clicked, this,
+		[this]() { emit this->ExitButtonClicked(); },
+		Qt::DirectConnection);
+
+	/* Transfer menu actions signals as OBSBasicControls signals */
+	connect(
+		startStreamAction.get(), &QAction::triggered, this,
+		[this]() { emit this->StartStreamMenuActionClicked(); },
+		Qt::DirectConnection);
+	connect(
+		stopStreamAction.get(), &QAction::triggered, this,
+		[this]() { emit this->StopStreamMenuActionClicked(); },
+		Qt::DirectConnection);
+	connect(
+		forceStopStreamAction, &QAction::triggered, this,
+		[this]() { emit this->ForceStopStreamMenuActionClicked(); },
+		Qt::DirectConnection);
+
+	/* Set up default visibilty */
+	ui->broadcastButton->setVisible(false);
+	ui->pauseRecordButton->setVisible(false);
+	ui->replayBufferButton->setVisible(false);
+	ui->saveReplayButton->setVisible(false);
+	ui->virtualCamButton->setVisible(false);
+	ui->virtualCamConfigButton->setVisible(false);
+
+	/* Set up state update connections */
+	connect(main, &OBSBasic::StreamingPreparing, this,
+		&OBSBasicControls::StreamingPreparing);
+	connect(main, &OBSBasic::StreamingStarting, this,
+		&OBSBasicControls::StreamingStarting);
+	connect(main, &OBSBasic::StreamingStarted, this,
+		&OBSBasicControls::StreamingStarted);
+	connect(main, &OBSBasic::StreamingStopping, this,
+		&OBSBasicControls::StreamingStopping);
+	connect(main, &OBSBasic::StreamingStopped, this,
+		&OBSBasicControls::StreamingStopped);
+
+	connect(main, &OBSBasic::BroadcastStreamReady, this,
+		&OBSBasicControls::BroadcastStreamReady);
+	connect(main, &OBSBasic::BroadcastStreamActive, this,
+		&OBSBasicControls::BroadcastStreamActive);
+	connect(main, &OBSBasic::BroadcastStreamStarted, this,
+		&OBSBasicControls::BroadcastStreamStarted);
+
+	connect(main, &OBSBasic::RecordingStarted, this,
+		&OBSBasicControls::RecordingStarted);
+	connect(main, &OBSBasic::RecordingPaused, this,
+		&OBSBasicControls::RecordingPaused);
+	connect(main, &OBSBasic::RecordingUnpaused, this,
+		&OBSBasicControls::RecordingUnpaused);
+	connect(main, &OBSBasic::RecordingStopping, this,
+		&OBSBasicControls::RecordingStopping);
+	connect(main, &OBSBasic::RecordingStopped, this,
+		&OBSBasicControls::RecordingStopped);
+
+	connect(main, &OBSBasic::ReplayBufStarted, this,
+		&OBSBasicControls::ReplayBufferStarted);
+	connect(main, &OBSBasic::ReplayBufferStopping, this,
+		&OBSBasicControls::ReplayBufferStopping);
+	connect(main, &OBSBasic::ReplayBufStopped, this,
+		&OBSBasicControls::ReplayBufferStopped);
+
+	connect(main, &OBSBasic::VirtualCamStarted, this,
+		&OBSBasicControls::VirtualCamStarted);
+	connect(main, &OBSBasic::VirtualCamStopped, this,
+		&OBSBasicControls::VirtualCamStopped);
+
+	connect(main, &OBSBasic::PreviewProgramModeChanged, this,
+		&OBSBasicControls::UpdateStudioModeState);
+
+	/* Set up enablement connection */
+	connect(main, &OBSBasic::BroadcastFlowEnabled, this,
+		&OBSBasicControls::EnableBroadcastFlow);
+	connect(main, &OBSBasic::ReplayBufEnabled, this,
+		&OBSBasicControls::EnableReplayBufferButtons);
+	connect(main, &OBSBasic::VirtualCamEnabled, this,
+		&OBSBasicControls::EnableVirtualCamButtons);
+}
+
+void OBSBasicControls::StreamingPreparing()
+{
+	ui->streamButton->setEnabled(false);
+	ui->streamButton->setText(QTStr("Basic.Main.PreparingStream"));
+}
+
+void OBSBasicControls::StreamingStarting(bool broadcastAutoStart)
+{
+	ui->streamButton->setText(QTStr("Basic.Main.Connecting"));
+
+	if (!broadcastAutoStart) {
+		// well, we need to disable button while stream is not active
+		ui->broadcastButton->setEnabled(false);
+
+		ui->broadcastButton->setText(
+			QTStr("Basic.Main.StartBroadcast"));
+
+		ui->broadcastButton->setProperty("broadcastState", "ready");
+		ui->broadcastButton->style()->unpolish(ui->broadcastButton);
+		ui->broadcastButton->style()->polish(ui->broadcastButton);
+	}
+}
+
+void OBSBasicControls::StreamingStarted(bool withDelay)
+{
+	ui->streamButton->setEnabled(true);
+	ui->streamButton->setChecked(true);
+	ui->streamButton->setText(QTStr("Basic.Main.StopStreaming"));
+
+	if (withDelay) {
+		ui->streamButton->setMenu(streamButtonMenu.get());
+		startStreamAction->setVisible(false);
+		stopStreamAction->setVisible(true);
+	}
+}
+
+void OBSBasicControls::StreamingStopping()
+{
+	ui->streamButton->setText(QTStr("Basic.Main.StoppingStreaming"));
+}
+
+void OBSBasicControls::StreamingStopped(bool withDelay)
+{
+	ui->streamButton->setEnabled(true);
+	ui->streamButton->setChecked(false);
+	ui->streamButton->setText(QTStr("Basic.Main.StartStreaming"));
+
+	if (withDelay) {
+		if (!ui->streamButton->menu())
+			ui->streamButton->setMenu(streamButtonMenu.get());
+
+		startStreamAction->setVisible(true);
+		stopStreamAction->setVisible(false);
+	} else {
+		ui->streamButton->setMenu(nullptr);
+	}
+}
+
+void OBSBasicControls::BroadcastStreamReady(bool ready)
+{
+	ui->broadcastButton->setChecked(ready);
+}
+
+void OBSBasicControls::BroadcastStreamActive()
+{
+	ui->broadcastButton->setEnabled(true);
+}
+
+void OBSBasicControls::BroadcastStreamStarted(bool autoStop)
+{
+	ui->broadcastButton->setText(
+		QTStr(autoStop ? "Basic.Main.AutoStopEnabled"
+			       : "Basic.Main.StopBroadcast"));
+	if (autoStop)
+		ui->broadcastButton->setEnabled(false);
+
+	ui->broadcastButton->setProperty("broadcastState", "active");
+	ui->broadcastButton->style()->unpolish(ui->broadcastButton);
+	ui->broadcastButton->style()->polish(ui->broadcastButton);
+}
+
+void OBSBasicControls::RecordingStarted(bool pausable)
+{
+	ui->recordButton->setChecked(true);
+	ui->recordButton->setText(QTStr("Basic.Main.StopRecording"));
+
+	if (pausable) {
+		ui->pauseRecordButton->setVisible(pausable);
+		RecordingUnpaused();
+	}
+}
+
+void OBSBasicControls::RecordingPaused()
+{
+	QString text = QTStr("Basic.Main.UnpauseRecording");
+
+	ui->pauseRecordButton->setChecked(true);
+	ui->pauseRecordButton->setAccessibleName(text);
+	ui->pauseRecordButton->setToolTip(text);
+
+	ui->saveReplayButton->setEnabled(false);
+}
+
+void OBSBasicControls::RecordingUnpaused()
+{
+	QString text = QTStr("Basic.Main.PauseRecording");
+
+	ui->pauseRecordButton->setChecked(false);
+	ui->pauseRecordButton->setAccessibleName(text);
+	ui->pauseRecordButton->setToolTip(text);
+
+	ui->saveReplayButton->setEnabled(true);
+}
+
+void OBSBasicControls::RecordingStopping()
+{
+	ui->recordButton->setText(QTStr("Basic.Main.StoppingRecording"));
+}
+
+void OBSBasicControls::RecordingStopped()
+{
+	ui->recordButton->setChecked(false);
+	ui->recordButton->setText(QTStr("Basic.Main.StartRecording"));
+
+	ui->pauseRecordButton->setVisible(false);
+}
+
+void OBSBasicControls::ReplayBufferStarted()
+{
+	ui->replayBufferButton->setChecked(true);
+	ui->replayBufferButton->setText(QTStr("Basic.Main.StopReplayBuffer"));
+
+	ui->saveReplayButton->setVisible(true);
+}
+
+void OBSBasicControls::ReplayBufferStopping()
+{
+	ui->replayBufferButton->setText(
+		QTStr("Basic.Main.StoppingReplayBuffer"));
+}
+
+void OBSBasicControls::ReplayBufferStopped()
+{
+	ui->replayBufferButton->setChecked(false);
+	ui->replayBufferButton->setText(QTStr("Basic.Main.StartReplayBuffer"));
+
+	ui->saveReplayButton->setVisible(false);
+}
+
+void OBSBasicControls::VirtualCamStarted()
+{
+	ui->virtualCamButton->setChecked(true);
+	ui->virtualCamButton->setText(QTStr("Basic.Main.StopVirtualCam"));
+}
+
+void OBSBasicControls::VirtualCamStopped()
+{
+	ui->virtualCamButton->setChecked(false);
+	ui->virtualCamButton->setText(QTStr("Basic.Main.StartVirtualCam"));
+}
+
+void OBSBasicControls::UpdateStudioModeState(bool enabled)
+{
+	ui->modeSwitch->setChecked(enabled);
+}
+
+void OBSBasicControls::EnableBroadcastFlow(bool enabled)
+{
+	ui->broadcastButton->setVisible(enabled);
+	ui->broadcastButton->setEnabled(enabled);
+
+	ui->broadcastButton->setText(QTStr("Basic.Main.SetupBroadcast"));
+
+	ui->broadcastButton->setProperty("broadcastState", "idle");
+	ui->broadcastButton->style()->unpolish(ui->broadcastButton);
+	ui->broadcastButton->style()->polish(ui->broadcastButton);
+}
+
+void OBSBasicControls::EnableReplayBufferButtons(bool enabled)
+{
+	ui->replayBufferButton->setVisible(enabled);
+}
+
+void OBSBasicControls::EnableVirtualCamButtons()
+{
+	ui->virtualCamButton->setVisible(true);
+	ui->virtualCamConfigButton->setVisible(true);
+}