mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-19 20:32:15 +02:00
710d99ef4d
When a source file contains an explicit include with a filename following the "moc_<actual-filename>.cpp" pattern, then CMake's AUTOMOC generation tool will recognize the matching pair and generate the replacement header file and add the required include directory entries. For all files which do contain Q_OBJECT or similar declarations but do not have an explicit include directive, the global mocs_compilation.cpp file will still be generated (which groups all "missing" generated headers). The larger this global file is, the more expensive incremental compilation will be as this file (and all its contained generated headers) will be re-generated regardless of whether actual changes occurred.
330 lines
9.8 KiB
C++
330 lines
9.8 KiB
C++
#include "moc_basic-controls.cpp"
|
|
|
|
#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::ReplayBufStopping, 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);
|
|
}
|