Skip to content

Commit 3165559

Browse files
tytan652tytan652
committed
[WIP] UI: Separate controls dock from the main window
I still need to work/fix appearance/theming…
1 parent 92d68c6 commit 3165559

12 files changed

+952
-746
lines changed

‎UI/basic-controls.cpp‎

Lines changed: 313 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,313 @@
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.data(), &QAction::triggered, this,
69+
[this]() { emit this->StartStreamMenuActionClicked(); },
70+
Qt::DirectConnection);
71+
connect(
72+
stopStreamAction.data(), &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+
/* Setup 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+
/* Setup 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::BroadcastStreamStarted, this,
101+
&OBSBasicControls::BroadcastStreamStarted);
102+
103+
connect(main, &OBSBasic::RecordingStarted, this,
104+
&OBSBasicControls::RecordingStarted);
105+
connect(main, &OBSBasic::RecordingPaused, this,
106+
&OBSBasicControls::RecordingPaused);
107+
connect(main, &OBSBasic::RecordingUnpaused, this,
108+
&OBSBasicControls::RecordingUnpaused);
109+
connect(main, &OBSBasic::RecordingStopping, this,
110+
&OBSBasicControls::RecordingStopping);
111+
connect(main, &OBSBasic::RecordingStopped, this,
112+
&OBSBasicControls::RecordingStopped);
113+
114+
connect(main, &OBSBasic::ReplayBufStarted, this,
115+
&OBSBasicControls::ReplayBufferStarted);
116+
connect(main, &OBSBasic::ReplayBufferStopping, this,
117+
&OBSBasicControls::ReplayBufferStopping);
118+
connect(main, &OBSBasic::ReplayBufStopped, this,
119+
&OBSBasicControls::ReplayBufferStopped);
120+
121+
connect(main, &OBSBasic::VirtualCamStarted, this,
122+
&OBSBasicControls::VirtualCamStarted);
123+
connect(main, &OBSBasic::VirtualCamStopped, this,
124+
&OBSBasicControls::VirtualCamStopped);
125+
126+
connect(main, &OBSBasic::PreviewProgramModeChanged, this,
127+
&OBSBasicControls::UpdateStudioModeState);
128+
129+
/* Setup enablement connection */
130+
connect(main, &OBSBasic::BroadcastFlowEnabled, this,
131+
&OBSBasicControls::EnableBroadcastFlow);
132+
connect(main, &OBSBasic::ReplayBufEnabled, this,
133+
&OBSBasicControls::EnableReplayBufferButtons);
134+
connect(main, &OBSBasic::VirtualCamEnabled, this,
135+
&OBSBasicControls::EnableVirtualCamButtons);
136+
}
137+
138+
void OBSBasicControls::StreamingStarting(bool broadcastAutoStart)
139+
{
140+
ui->streamButton->setEnabled(false);
141+
ui->streamButton->setText(QTStr("Basic.Main.Connecting"));
142+
143+
if (!broadcastAutoStart) {
144+
// well, we need to disable button while stream is not active
145+
ui->broadcastButton->setEnabled(false);
146+
147+
ui->broadcastButton->setText(
148+
QTStr("Basic.Main.StartBroadcast"));
149+
150+
ui->broadcastButton->setProperty("broadcastState", "ready");
151+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
152+
ui->broadcastButton->style()->polish(ui->broadcastButton);
153+
}
154+
}
155+
156+
void OBSBasicControls::StreamingStarted(bool withDelay)
157+
{
158+
ui->streamButton->setEnabled(true);
159+
ui->streamButton->setChecked(true);
160+
ui->streamButton->setText(QTStr("Basic.Main.StopStreaming"));
161+
162+
if (withDelay) {
163+
ui->streamButton->setMenu(streamButtonMenu.data());
164+
startStreamAction->setVisible(false);
165+
stopStreamAction->setVisible(true);
166+
}
167+
}
168+
169+
void OBSBasicControls::StreamingStopping()
170+
{
171+
ui->streamButton->setText(QTStr("Basic.Main.StoppingStreaming"));
172+
}
173+
174+
void OBSBasicControls::StreamingStopped(bool withDelay)
175+
{
176+
ui->streamButton->setEnabled(true);
177+
ui->streamButton->setChecked(false);
178+
ui->streamButton->setText(QTStr("Basic.Main.StartStreaming"));
179+
180+
if (withDelay) {
181+
if (!ui->streamButton->menu())
182+
ui->streamButton->setMenu(streamButtonMenu.data());
183+
184+
startStreamAction->setVisible(true);
185+
stopStreamAction->setVisible(false);
186+
} else
187+
ui->streamButton->setMenu(nullptr);
188+
}
189+
190+
void OBSBasicControls::BroadcastStreamReady(bool ready)
191+
{
192+
ui->broadcastButton->setChecked(ready);
193+
}
194+
195+
void OBSBasicControls::BroadcastStreamStarted(bool autoStop)
196+
{
197+
ui->broadcastButton->setText(
198+
QTStr(autoStop ? "Basic.Main.AutoStopEnabled"
199+
: "Basic.Main.StopBroadcast"));
200+
ui->broadcastButton->setEnabled(!autoStop);
201+
202+
ui->broadcastButton->setProperty("broadcastState", "active");
203+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
204+
ui->broadcastButton->style()->polish(ui->broadcastButton);
205+
}
206+
207+
void OBSBasicControls::RecordingStarted(bool pausable)
208+
{
209+
ui->recordButton->setChecked(true);
210+
ui->recordButton->setText(QTStr("Basic.Main.StopRecording"));
211+
212+
if (pausable) {
213+
ui->pauseRecordButton->setVisible(pausable);
214+
RecordingUnpaused();
215+
}
216+
}
217+
218+
void OBSBasicControls::RecordingPaused()
219+
{
220+
QString text = QTStr("Basic.Main.UnpauseRecording");
221+
222+
ui->pauseRecordButton->setChecked(true);
223+
ui->pauseRecordButton->setAccessibleName(text);
224+
ui->pauseRecordButton->setToolTip(text);
225+
226+
ui->replayBufferButton->setEnabled(false);
227+
}
228+
229+
void OBSBasicControls::RecordingUnpaused()
230+
{
231+
QString text = QTStr("Basic.Main.PauseRecording");
232+
233+
ui->pauseRecordButton->setChecked(false);
234+
ui->pauseRecordButton->setAccessibleName(text);
235+
ui->pauseRecordButton->setToolTip(text);
236+
237+
ui->replayBufferButton->setEnabled(true);
238+
}
239+
240+
void OBSBasicControls::RecordingStopping()
241+
{
242+
ui->recordButton->setText(QTStr("Basic.Main.StoppingRecording"));
243+
}
244+
245+
void OBSBasicControls::RecordingStopped()
246+
{
247+
ui->recordButton->setChecked(false);
248+
ui->recordButton->setText(QTStr("Basic.Main.StartRecording"));
249+
250+
ui->pauseRecordButton->setVisible(false);
251+
}
252+
253+
void OBSBasicControls::ReplayBufferStarted()
254+
{
255+
ui->replayBufferButton->setChecked(true);
256+
ui->replayBufferButton->setText(QTStr("Basic.Main.StopReplayBuffer"));
257+
258+
ui->saveReplayButton->setVisible(true);
259+
}
260+
261+
void OBSBasicControls::ReplayBufferStopping()
262+
{
263+
ui->replayBufferButton->setText(
264+
QTStr("Basic.Main.StoppingReplayBuffer"));
265+
}
266+
267+
void OBSBasicControls::ReplayBufferStopped()
268+
{
269+
ui->replayBufferButton->setChecked(false);
270+
ui->replayBufferButton->setText(QTStr("Basic.Main.StartReplayBuffer"));
271+
272+
ui->saveReplayButton->setVisible(false);
273+
}
274+
275+
void OBSBasicControls::VirtualCamStarted()
276+
{
277+
ui->virtualCamButton->setChecked(true);
278+
ui->virtualCamButton->setText(QTStr("Basic.Main.StopVirtualCam"));
279+
}
280+
281+
void OBSBasicControls::VirtualCamStopped()
282+
{
283+
ui->virtualCamButton->setChecked(false);
284+
ui->virtualCamButton->setText(QTStr("Basic.Main.StartVirtualCam"));
285+
}
286+
287+
void OBSBasicControls::UpdateStudioModeState(bool enabled)
288+
{
289+
ui->modeSwitch->setChecked(enabled);
290+
}
291+
292+
void OBSBasicControls::EnableBroadcastFlow(bool enabled)
293+
{
294+
ui->broadcastButton->setVisible(enabled);
295+
ui->broadcastButton->setEnabled(enabled);
296+
297+
ui->broadcastButton->setText(QTStr("Basic.Main.SetupBroadcast"));
298+
299+
ui->broadcastButton->setProperty("broadcastState", "idle");
300+
ui->broadcastButton->style()->unpolish(ui->broadcastButton);
301+
ui->broadcastButton->style()->polish(ui->broadcastButton);
302+
}
303+
304+
void OBSBasicControls::EnableReplayBufferButtons(bool enabled)
305+
{
306+
ui->replayBufferButton->setVisible(enabled);
307+
}
308+
309+
void OBSBasicControls::EnableVirtualCamButtons()
310+
{
311+
ui->virtualCamButton->setVisible(true);
312+
ui->virtualCamConfigButton->setVisible(true);
313+
}

‎UI/basic-controls.hpp‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
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 BroadcastStreamStarted(bool autoStop);
30+
31+
void RecordingStarted(bool pausable);
32+
void RecordingPaused();
33+
void RecordingUnpaused();
34+
void RecordingStopping();
35+
void RecordingStopped();
36+
37+
void ReplayBufferStarted();
38+
void ReplayBufferStopping();
39+
void ReplayBufferStopped();
40+
41+
void VirtualCamStarted();
42+
void VirtualCamStopped();
43+
44+
void UpdateStudioModeState(bool enabled);
45+
46+
void EnableBroadcastFlow(bool enabled);
47+
void EnableReplayBufferButtons(bool enabled);
48+
void EnableVirtualCamButtons();
49+
50+
public:
51+
OBSBasicControls(OBSBasic *main);
52+
inline ~OBSBasicControls() {}
53+
54+
signals:
55+
void StreamButtonClicked();
56+
void BroadcastButtonClicked();
57+
void RecordButtonClicked();
58+
void PauseRecordButtonClicked();
59+
void ReplayBufferButtonClicked();
60+
void SaveReplayBufferButtonClicked();
61+
void VirtualCamButtonClicked();
62+
void VirtualCamConfigButtonClicked();
63+
void StudioModeButtonClicked();
64+
void SettingsButtonClicked();
65+
void ExitButtonClicked();
66+
67+
void StartStreamMenuActionClicked();
68+
void StopStreamMenuActionClicked();
69+
void ForceStopStreamMenuActionClicked();
70+
};

0 commit comments

Comments
 (0)