Skip to content

Commit 10e25f2

Browse files
tytan652tytan652
committed
UI: Separate controls dock from the main window
1 parent a1f3e70 commit 10e25f2

13 files changed

Lines changed: 973 additions & 746 deletions

‎UI/basic-controls.cpp‎

Lines changed: 321 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,321 @@
1+
#include "basic-controls.hpp"
2+
3+
#include "window-basic-main.hpp"
4+
5+
OBSBasicControls::OBSBasicControls(OBSBasic *main)
6+
: QFrame(nullptr),
7+
ui(new Ui::OBSBasicControls)
8+
{
9+
/* Create UI elements */
10+
ui->setupUi(this);
11+
12+
streamButtonMenu.reset(new QMenu());
13+
startStreamAction =
14+
streamButtonMenu->addAction(QTStr("Basic.Main.StartStreaming"));
15+
stopStreamAction =
16+
streamButtonMenu->addAction(QTStr("Basic.Main.StopStreaming"));
17+
QAction *forceStopStreamAction = streamButtonMenu->addAction(
18+
QTStr("Basic.Main.ForceStopStreaming"));
19+
20+
/* Transfer buttons signals as OBSBasicControls signals */
21+
connect(
22+
ui->streamButton, &QPushButton::clicked, this,
23+
[this]() { emit this->StreamButtonClicked(); },
24+
Qt::DirectConnection);
25+
connect(
26+
ui->broadcastButton, &QPushButton::clicked, this,
27+
[this]() { emit this->BroadcastButtonClicked(); },
28+
Qt::DirectConnection);
29+
connect(
30+
ui->recordButton, &QPushButton::clicked, this,
31+
[this]() { emit this->RecordButtonClicked(); },
32+
Qt::DirectConnection);
33+
connect(
34+
ui->pauseRecordButton, &QPushButton::clicked, this,
35+
[this]() { emit this->PauseRecordButtonClicked(); },
36+
Qt::DirectConnection);
37+
connect(
38+
ui->replayBufferButton, &QPushButton::clicked, this,
39+
[this]() { emit this->ReplayBufferButtonClicked(); },
40+
Qt::DirectConnection);
41+
connect(
42+
ui->saveReplayButton, &QPushButton::clicked, this,
43+
[this]() { emit this->SaveReplayBufferButtonClicked(); },
44+
Qt::DirectConnection);
45+
connect(
46+
ui->virtualCamButton, &QPushButton::clicked, this,
47+
[this]() { emit this->VirtualCamButtonClicked(); },
48+
Qt::DirectConnection);
49+
connect(
50+
ui->virtualCamConfigButton, &QPushButton::clicked, this,
51+
[this]() { emit this->VirtualCamConfigButtonClicked(); },
52+
Qt::DirectConnection);
53+
connect(
54+
ui->modeSwitch, &QPushButton::clicked, this,
55+
[this]() { emit this->StudioModeButtonClicked(); },
56+
Qt::DirectConnection);
57+
connect(
58+
ui->settingsButton, &QPushButton::clicked, this,
59+
[this]() { emit this->SettingsButtonClicked(); },
60+
Qt::DirectConnection);
61+
connect(
62+
ui->exitButton, &QPushButton::clicked, this,
63+
[this]() { emit this->ExitButtonClicked(); },
64+
Qt::DirectConnection);
65+
66+
/* Transfer menu actions signals as OBSBasicControls signals */
67+
connect(
68+
startStreamAction.get(), &QAction::triggered, this,
69+
[this]() { emit this->StartStreamMenuActionClicked(); },
70+
Qt::DirectConnection);
71+
connect(
72+
stopStreamAction.get(), &QAction::triggered, this,
73+
[this]() { emit this->StopStreamMenuActionClicked(); },
74+
Qt::DirectConnection);
75+
connect(
76+
forceStopStreamAction, &QAction::triggered, this,
77+
[this]() { emit this->ForceStopStreamMenuActionClicked(); },
78+
Qt::DirectConnection);
79+
80+
/* Set up default visibilty */
81+
ui->broadcastButton->setVisible(false);
82+
ui->pauseRecordButton->setVisible(false);
83+
ui->replayBufferButton->setVisible(false);
84+
ui->saveReplayButton->setVisible(false);
85+
ui->virtualCamButton->setVisible(false);
86+
ui->virtualCamConfigButton->setVisible(false);
87+
88+
/* Set up state update connections */
89+
connect(main, &OBSBasic::StreamingStarting, this,
90+
&OBSBasicControls::StreamingStarting);
91+
connect(main, &OBSBasic::StreamingStarted, this,
92+
&OBSBasicControls::StreamingStarted);
93+
connect(main, &OBSBasic::StreamingStopping, this,
94+
&OBSBasicControls::StreamingStopping);
95+
connect(main, &OBSBasic::StreamingStopped, this,
96+
&OBSBasicControls::StreamingStopped);
97+
98+
connect(main, &OBSBasic::BroadcastStreamReady, this,
99+
&OBSBasicControls::BroadcastStreamReady);
100+
connect(main, &OBSBasic::BroadcastStreamActive, this,
101+
&OBSBasicControls::BroadcastStreamActive);
102+
connect(main, &OBSBasic::BroadcastStreamStarted, this,
103+
&OBSBasicControls::BroadcastStreamStarted);
104+
105+
connect(main, &OBSBasic::RecordingStarted, this,
106+
&OBSBasicControls::RecordingStarted);
107+
connect(main, &OBSBasic::RecordingPaused, this,
108+
&OBSBasicControls::RecordingPaused);
109+
connect(main, &OBSBasic::RecordingUnpaused, this,
110+
&OBSBasicControls::RecordingUnpaused);
111+
connect(main, &OBSBasic::RecordingStopping, this,
112+
&OBSBasicControls::RecordingStopping);
113+
connect(main, &OBSBasic::RecordingStopped, this,
114+
&OBSBasicControls::RecordingStopped);
115+
116+
connect(main, &OBSBasic::ReplayBufStarted, this,
117+
&OBSBasicControls::ReplayBufferStarted);
118+
connect(main, &OBSBasic::ReplayBufferStopping, this,
119+
&OBSBasicControls::ReplayBufferStopping);
120+
connect(main, &OBSBasic::ReplayBufStopped, this,
121+
&OBSBasicControls::ReplayBufferStopped);
122+
123+
connect(main, &OBSBasic::VirtualCamStarted, this,
124+
&OBSBasicControls::VirtualCamStarted);
125+
connect(main, &OBSBasic::VirtualCamStopped, this,
126+
&OBSBasicControls::VirtualCamStopped);
127+
128+
connect(main, &OBSBasic::PreviewProgramModeChanged, this,
129+
&OBSBasicControls::UpdateStudioModeState);
130+
131+
/* Set up enablement connection */
132+
connect(main, &OBSBasic::BroadcastFlowEnabled, this,
133+
&OBSBasicControls::EnableBroadcastFlow);
134+
connect(main, &OBSBasic::ReplayBufEnabled, this,
135+
&OBSBasicControls::EnableReplayBufferButtons);
136+
connect(main, &OBSBasic::VirtualCamEnabled, this,
137+
&OBSBasicControls::EnableVirtualCamButtons);
138+
}
139+
140+
void OBSBasicControls::StreamingStarting(bool broadcastAutoStart)
141+
{
142+
ui->streamButton->setEnabled(false);
143+
ui->streamButton->setText(QTStr("Basic.Main.Connecting"));
144+
145+
if (!broadcastAutoStart) {
146+
// well, we need to disable button while stream is not active
147+
ui->broadcastButton->setEnabled(false);
148+
149+
ui->broadcastButton->setText(
150+
QTStr("Basic.Main.StartBroadcast"));
151+
152+
ui->broadcastButton->setProperty("broadcastState", "ready");
153+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
154+
ui->broadcastButton->style()->polish(ui->broadcastButton);
155+
}
156+
}
157+
158+
void OBSBasicControls::StreamingStarted(bool withDelay)
159+
{
160+
ui->streamButton->setEnabled(true);
161+
ui->streamButton->setChecked(true);
162+
ui->streamButton->setText(QTStr("Basic.Main.StopStreaming"));
163+
164+
if (withDelay) {
165+
ui->streamButton->setMenu(streamButtonMenu.get());
166+
startStreamAction->setVisible(false);
167+
stopStreamAction->setVisible(true);
168+
}
169+
}
170+
171+
void OBSBasicControls::StreamingStopping()
172+
{
173+
ui->streamButton->setText(QTStr("Basic.Main.StoppingStreaming"));
174+
}
175+
176+
void OBSBasicControls::StreamingStopped(bool withDelay)
177+
{
178+
ui->streamButton->setEnabled(true);
179+
ui->streamButton->setChecked(false);
180+
ui->streamButton->setText(QTStr("Basic.Main.StartStreaming"));
181+
182+
if (withDelay) {
183+
if (!ui->streamButton->menu())
184+
ui->streamButton->setMenu(streamButtonMenu.get());
185+
186+
startStreamAction->setVisible(true);
187+
stopStreamAction->setVisible(false);
188+
} else
189+
ui->streamButton->setMenu(nullptr);
190+
}
191+
192+
void OBSBasicControls::BroadcastStreamReady(bool ready)
193+
{
194+
ui->broadcastButton->setChecked(ready);
195+
}
196+
197+
void OBSBasicControls::BroadcastStreamActive()
198+
{
199+
ui->broadcastButton->setEnabled(true);
200+
}
201+
202+
void OBSBasicControls::BroadcastStreamStarted(bool autoStop)
203+
{
204+
ui->broadcastButton->setText(
205+
QTStr(autoStop ? "Basic.Main.AutoStopEnabled"
206+
: "Basic.Main.StopBroadcast"));
207+
if (autoStop)
208+
ui->broadcastButton->setEnabled(false);
209+
210+
ui->broadcastButton->setProperty("broadcastState", "active");
211+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
212+
ui->broadcastButton->style()->polish(ui->broadcastButton);
213+
}
214+
215+
void OBSBasicControls::RecordingStarted(bool pausable)
216+
{
217+
ui->recordButton->setChecked(true);
218+
ui->recordButton->setText(QTStr("Basic.Main.StopRecording"));
219+
220+
if (pausable) {
221+
ui->pauseRecordButton->setVisible(pausable);
222+
RecordingUnpaused();
223+
}
224+
}
225+
226+
void OBSBasicControls::RecordingPaused()
227+
{
228+
QString text = QTStr("Basic.Main.UnpauseRecording");
229+
230+
ui->pauseRecordButton->setChecked(true);
231+
ui->pauseRecordButton->setAccessibleName(text);
232+
ui->pauseRecordButton->setToolTip(text);
233+
234+
ui->saveReplayButton->setEnabled(false);
235+
}
236+
237+
void OBSBasicControls::RecordingUnpaused()
238+
{
239+
QString text = QTStr("Basic.Main.PauseRecording");
240+
241+
ui->pauseRecordButton->setChecked(false);
242+
ui->pauseRecordButton->setAccessibleName(text);
243+
ui->pauseRecordButton->setToolTip(text);
244+
245+
ui->saveReplayButton->setEnabled(true);
246+
}
247+
248+
void OBSBasicControls::RecordingStopping()
249+
{
250+
ui->recordButton->setText(QTStr("Basic.Main.StoppingRecording"));
251+
}
252+
253+
void OBSBasicControls::RecordingStopped()
254+
{
255+
ui->recordButton->setChecked(false);
256+
ui->recordButton->setText(QTStr("Basic.Main.StartRecording"));
257+
258+
ui->pauseRecordButton->setVisible(false);
259+
}
260+
261+
void OBSBasicControls::ReplayBufferStarted()
262+
{
263+
ui->replayBufferButton->setChecked(true);
264+
ui->replayBufferButton->setText(QTStr("Basic.Main.StopReplayBuffer"));
265+
266+
ui->saveReplayButton->setVisible(true);
267+
}
268+
269+
void OBSBasicControls::ReplayBufferStopping()
270+
{
271+
ui->replayBufferButton->setText(
272+
QTStr("Basic.Main.StoppingReplayBuffer"));
273+
}
274+
275+
void OBSBasicControls::ReplayBufferStopped()
276+
{
277+
ui->replayBufferButton->setChecked(false);
278+
ui->replayBufferButton->setText(QTStr("Basic.Main.StartReplayBuffer"));
279+
280+
ui->saveReplayButton->setVisible(false);
281+
}
282+
283+
void OBSBasicControls::VirtualCamStarted()
284+
{
285+
ui->virtualCamButton->setChecked(true);
286+
ui->virtualCamButton->setText(QTStr("Basic.Main.StopVirtualCam"));
287+
}
288+
289+
void OBSBasicControls::VirtualCamStopped()
290+
{
291+
ui->virtualCamButton->setChecked(false);
292+
ui->virtualCamButton->setText(QTStr("Basic.Main.StartVirtualCam"));
293+
}
294+
295+
void OBSBasicControls::UpdateStudioModeState(bool enabled)
296+
{
297+
ui->modeSwitch->setChecked(enabled);
298+
}
299+
300+
void OBSBasicControls::EnableBroadcastFlow(bool enabled)
301+
{
302+
ui->broadcastButton->setVisible(enabled);
303+
ui->broadcastButton->setEnabled(enabled);
304+
305+
ui->broadcastButton->setText(QTStr("Basic.Main.SetupBroadcast"));
306+
307+
ui->broadcastButton->setProperty("broadcastState", "idle");
308+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
309+
ui->broadcastButton->style()->polish(ui->broadcastButton);
310+
}
311+
312+
void OBSBasicControls::EnableReplayBufferButtons(bool enabled)
313+
{
314+
ui->replayBufferButton->setVisible(enabled);
315+
}
316+
317+
void OBSBasicControls::EnableVirtualCamButtons()
318+
{
319+
ui->virtualCamButton->setVisible(true);
320+
ui->virtualCamConfigButton->setVisible(true);
321+
}

‎UI/basic-controls.hpp‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
#pragma once
2+
3+
#include <memory>
4+
5+
#include <QFrame>
6+
#include <QPointer>
7+
#include <QScopedPointer>
8+
9+
class OBSBasic;
10+
11+
#include "ui_OBSBasicControls.h"
12+
13+
class OBSBasicControls : public QFrame {
14+
Q_OBJECT
15+
16+
std::unique_ptr<Ui::OBSBasicControls> ui;
17+
18+
QScopedPointer<QMenu> streamButtonMenu;
19+
QPointer<QAction> startStreamAction;
20+
QPointer<QAction> stopStreamAction;
21+
22+
private slots:
23+
void StreamingStarting(bool broadcastAutoStart);
24+
void StreamingStarted(bool withDelay);
25+
void StreamingStopping();
26+
void StreamingStopped(bool withDelay);
27+
28+
void BroadcastStreamReady(bool ready);
29+
void BroadcastStreamActive();
30+
void BroadcastStreamStarted(bool autoStop);
31+
32+
void RecordingStarted(bool pausable);
33+
void RecordingPaused();
34+
void RecordingUnpaused();
35+
void RecordingStopping();
36+
void RecordingStopped();
37+
38+
void ReplayBufferStarted();
39+
void ReplayBufferStopping();
40+
void ReplayBufferStopped();
41+
42+
void VirtualCamStarted();
43+
void VirtualCamStopped();
44+
45+
void UpdateStudioModeState(bool enabled);
46+
47+
void EnableBroadcastFlow(bool enabled);
48+
void EnableReplayBufferButtons(bool enabled);
49+
void EnableVirtualCamButtons();
50+
51+
public:
52+
OBSBasicControls(OBSBasic *main);
53+
inline ~OBSBasicControls() {}
54+
55+
signals:
56+
void StreamButtonClicked();
57+
void BroadcastButtonClicked();
58+
void RecordButtonClicked();
59+
void PauseRecordButtonClicked();
60+
void ReplayBufferButtonClicked();
61+
void SaveReplayBufferButtonClicked();
62+
void VirtualCamButtonClicked();
63+
void VirtualCamConfigButtonClicked();
64+
void StudioModeButtonClicked();
65+
void SettingsButtonClicked();
66+
void ExitButtonClicked();
67+
68+
void StartStreamMenuActionClicked();
69+
void StopStreamMenuActionClicked();
70+
void ForceStopStreamMenuActionClicked();
71+
};

0 commit comments

Comments
 (0)