|
|
@@ -1,97 +1,66 @@
|
|
|
-#include <QLabel>
|
|
|
-#include <QHBoxLayout>
|
|
|
#include <QPainter>
|
|
|
#include <QPixmap>
|
|
|
#include "obs-app.hpp"
|
|
|
#include "window-basic-main.hpp"
|
|
|
#include "window-basic-status-bar.hpp"
|
|
|
#include "window-basic-main-outputs.hpp"
|
|
|
+#include "qt-wrappers.hpp"
|
|
|
+#include "platform.hpp"
|
|
|
+
|
|
|
+#include "ui_StatusBarWidget.h"
|
|
|
+
|
|
|
+static constexpr int bitrateUpdateSeconds = 2;
|
|
|
+static constexpr int congestionUpdateSeconds = 4;
|
|
|
+static constexpr float excellentThreshold = 0.0f;
|
|
|
+static constexpr float goodThreshold = 0.3333f;
|
|
|
+static constexpr float mediocreThreshold = 0.6667f;
|
|
|
+static constexpr float badThreshold = 1.0f;
|
|
|
+
|
|
|
+StatusBarWidget::StatusBarWidget(QWidget *parent)
|
|
|
+ : QWidget(parent),
|
|
|
+ ui(new Ui::StatusBarWidget)
|
|
|
+{
|
|
|
+ ui->setupUi(this);
|
|
|
+}
|
|
|
+
|
|
|
+StatusBarWidget::~StatusBarWidget() {}
|
|
|
|
|
|
OBSBasicStatusBar::OBSBasicStatusBar(QWidget *parent)
|
|
|
: QStatusBar(parent),
|
|
|
- delayInfo(new QLabel),
|
|
|
- droppedFrames(new QLabel),
|
|
|
- streamIcon(new QLabel),
|
|
|
- streamTime(new QLabel),
|
|
|
- recordTime(new QLabel),
|
|
|
- recordIcon(new QLabel),
|
|
|
- cpuUsage(new QLabel),
|
|
|
- transparentPixmap(20, 20),
|
|
|
- greenPixmap(20, 20),
|
|
|
- grayPixmap(20, 20),
|
|
|
- redPixmap(20, 20),
|
|
|
+ excellentPixmap(QIcon(":/res/images/network-excellent.svg")
|
|
|
+ .pixmap(QSize(16, 16))),
|
|
|
+ goodPixmap(
|
|
|
+ QIcon(":/res/images/network-good.svg").pixmap(QSize(16, 16))),
|
|
|
+ mediocrePixmap(QIcon(":/res/images/network-mediocre.svg")
|
|
|
+ .pixmap(QSize(16, 16))),
|
|
|
+ badPixmap(
|
|
|
+ QIcon(":/res/images/network-bad.svg").pixmap(QSize(16, 16))),
|
|
|
recordingActivePixmap(QIcon(":/res/images/recording-active.svg")
|
|
|
- .pixmap(QSize(20, 20))),
|
|
|
+ .pixmap(QSize(16, 16))),
|
|
|
recordingPausePixmap(QIcon(":/res/images/recording-pause.svg")
|
|
|
- .pixmap(QSize(20, 20))),
|
|
|
- recordingPauseInactivePixmap(
|
|
|
- QIcon(":/res/images/recording-pause-inactive.svg")
|
|
|
- .pixmap(QSize(20, 20))),
|
|
|
- recordingInactivePixmap(QIcon(":/res/images/recording-inactive.svg")
|
|
|
- .pixmap(QSize(20, 20))),
|
|
|
+ .pixmap(QSize(16, 16))),
|
|
|
streamingActivePixmap(QIcon(":/res/images/streaming-active.svg")
|
|
|
- .pixmap(QSize(20, 20))),
|
|
|
- streamingInactivePixmap(QIcon(":/res/images/streaming-inactive.svg")
|
|
|
- .pixmap(QSize(20, 20)))
|
|
|
+ .pixmap(QSize(16, 16)))
|
|
|
{
|
|
|
- streamTime->setText(QString("LIVE: 00:00:00"));
|
|
|
- recordTime->setText(QString("REC: 00:00:00"));
|
|
|
- cpuUsage->setText(QString("CPU: 0.0%, 0.00 fps"));
|
|
|
-
|
|
|
- streamIcon->setPixmap(streamingInactivePixmap);
|
|
|
- recordIcon->setPixmap(recordingInactivePixmap);
|
|
|
-
|
|
|
- QWidget *brWidget = new QWidget(this);
|
|
|
- QHBoxLayout *brLayout = new QHBoxLayout(brWidget);
|
|
|
- brLayout->setContentsMargins(0, 0, 0, 0);
|
|
|
-
|
|
|
- statusSquare = new QLabel(brWidget);
|
|
|
- brLayout->addWidget(statusSquare);
|
|
|
-
|
|
|
- kbps = new QLabel(brWidget);
|
|
|
- brLayout->addWidget(kbps);
|
|
|
-
|
|
|
- brWidget->setLayout(brLayout);
|
|
|
-
|
|
|
- delayInfo->setAlignment(Qt::AlignRight);
|
|
|
- delayInfo->setAlignment(Qt::AlignVCenter);
|
|
|
- droppedFrames->setAlignment(Qt::AlignRight);
|
|
|
- droppedFrames->setAlignment(Qt::AlignVCenter);
|
|
|
- streamIcon->setAlignment(Qt::AlignRight);
|
|
|
- streamIcon->setAlignment(Qt::AlignVCenter);
|
|
|
- streamTime->setAlignment(Qt::AlignRight);
|
|
|
- streamTime->setAlignment(Qt::AlignVCenter);
|
|
|
- recordIcon->setAlignment(Qt::AlignRight);
|
|
|
- recordIcon->setAlignment(Qt::AlignVCenter);
|
|
|
- recordTime->setAlignment(Qt::AlignRight);
|
|
|
- recordTime->setAlignment(Qt::AlignVCenter);
|
|
|
- cpuUsage->setAlignment(Qt::AlignRight);
|
|
|
- cpuUsage->setAlignment(Qt::AlignVCenter);
|
|
|
- kbps->setAlignment(Qt::AlignRight);
|
|
|
- kbps->setAlignment(Qt::AlignVCenter);
|
|
|
-
|
|
|
- delayInfo->setIndent(20);
|
|
|
- droppedFrames->setIndent(20);
|
|
|
- streamIcon->setIndent(20);
|
|
|
- recordIcon->setIndent(20);
|
|
|
- cpuUsage->setIndent(20);
|
|
|
- kbps->setIndent(10);
|
|
|
-
|
|
|
- addPermanentWidget(droppedFrames);
|
|
|
- addPermanentWidget(streamIcon);
|
|
|
- addPermanentWidget(streamTime);
|
|
|
- addPermanentWidget(recordIcon);
|
|
|
- addPermanentWidget(recordTime);
|
|
|
- addPermanentWidget(cpuUsage);
|
|
|
- addPermanentWidget(delayInfo);
|
|
|
- addPermanentWidget(brWidget);
|
|
|
-
|
|
|
- transparentPixmap.fill(QColor(0, 0, 0, 0));
|
|
|
- greenPixmap.fill(QColor(0, 255, 0));
|
|
|
- grayPixmap.fill(QColor(72, 72, 72));
|
|
|
- redPixmap.fill(QColor(255, 0, 0));
|
|
|
-
|
|
|
- statusSquare->setPixmap(transparentPixmap);
|
|
|
+ statusWidget = new StatusBarWidget(this);
|
|
|
+ statusWidget->ui->delayInfo->setText("");
|
|
|
+ statusWidget->ui->droppedFrames->setText(
|
|
|
+ QTStr("DroppedFrames").arg("0", "0.0"));
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(inactivePixmap);
|
|
|
+ statusWidget->ui->streamIcon->setPixmap(streamingInactivePixmap);
|
|
|
+ statusWidget->ui->streamTime->setDisabled(true);
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(recordingInactivePixmap);
|
|
|
+ statusWidget->ui->recordTime->setDisabled(true);
|
|
|
+ statusWidget->ui->delayFrame->hide();
|
|
|
+ statusWidget->ui->issuesFrame->hide();
|
|
|
+ statusWidget->ui->kbps->hide();
|
|
|
+
|
|
|
+ addPermanentWidget(statusWidget);
|
|
|
+ setMinimumHeight(statusWidget->height());
|
|
|
+
|
|
|
+ UpdateIcons();
|
|
|
+ connect(App(), &OBSApp::StyleChanged, this,
|
|
|
+ &OBSBasicStatusBar::UpdateIcons);
|
|
|
}
|
|
|
|
|
|
void OBSBasicStatusBar::Activate()
|
|
|
@@ -114,16 +83,21 @@ void OBSBasicStatusBar::Activate()
|
|
|
active = true;
|
|
|
|
|
|
if (streamOutput) {
|
|
|
- statusSquare->setPixmap(grayPixmap);
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(inactivePixmap);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (streamOutput) {
|
|
|
- streamIcon->setPixmap(streamingActivePixmap);
|
|
|
+ statusWidget->ui->streamIcon->setPixmap(streamingActivePixmap);
|
|
|
+ statusWidget->ui->streamTime->setDisabled(false);
|
|
|
+ statusWidget->ui->issuesFrame->show();
|
|
|
+ statusWidget->ui->kbps->show();
|
|
|
+ firstCongestionUpdate = true;
|
|
|
}
|
|
|
|
|
|
if (recordOutput) {
|
|
|
- recordIcon->setPixmap(recordingActivePixmap);
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(recordingActivePixmap);
|
|
|
+ statusWidget->ui->recordTime->setDisabled(false);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -134,23 +108,35 @@ void OBSBasicStatusBar::Deactivate()
|
|
|
return;
|
|
|
|
|
|
if (!streamOutput) {
|
|
|
- streamTime->setText(QString("LIVE: 00:00:00"));
|
|
|
- streamIcon->setPixmap(streamingInactivePixmap);
|
|
|
+ statusWidget->ui->streamTime->setText(QString("00:00:00"));
|
|
|
+ statusWidget->ui->streamTime->setDisabled(true);
|
|
|
+ statusWidget->ui->streamIcon->setPixmap(
|
|
|
+ streamingInactivePixmap);
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(inactivePixmap);
|
|
|
+ statusWidget->ui->delayFrame->hide();
|
|
|
+ statusWidget->ui->issuesFrame->hide();
|
|
|
+ statusWidget->ui->kbps->hide();
|
|
|
totalStreamSeconds = 0;
|
|
|
+ congestionArray.clear();
|
|
|
+ disconnected = false;
|
|
|
+ firstCongestionUpdate = false;
|
|
|
}
|
|
|
|
|
|
if (!recordOutput) {
|
|
|
- recordTime->setText(QString("REC: 00:00:00"));
|
|
|
- recordIcon->setPixmap(recordingInactivePixmap);
|
|
|
+ statusWidget->ui->recordTime->setText(QString("00:00:00"));
|
|
|
+ statusWidget->ui->recordTime->setDisabled(true);
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(
|
|
|
+ recordingInactivePixmap);
|
|
|
totalRecordSeconds = 0;
|
|
|
}
|
|
|
|
|
|
if (main->outputHandler && !main->outputHandler->Active()) {
|
|
|
delete refreshTimer;
|
|
|
|
|
|
- delayInfo->setText("");
|
|
|
- droppedFrames->setText("");
|
|
|
- kbps->setText("");
|
|
|
+ statusWidget->ui->delayInfo->setText("");
|
|
|
+ statusWidget->ui->droppedFrames->setText(
|
|
|
+ QTStr("DroppedFrames").arg("0", "0.0"));
|
|
|
+ statusWidget->ui->kbps->setText("0 kbps");
|
|
|
|
|
|
delaySecTotal = 0;
|
|
|
delaySecStarting = 0;
|
|
|
@@ -159,7 +145,7 @@ void OBSBasicStatusBar::Deactivate()
|
|
|
active = false;
|
|
|
overloadedNotify = true;
|
|
|
|
|
|
- statusSquare->setPixmap(transparentPixmap);
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(inactivePixmap);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -184,19 +170,20 @@ void OBSBasicStatusBar::UpdateDelayMsg()
|
|
|
msg = QTStr("Basic.StatusBar.Delay");
|
|
|
msg = msg.arg(QString::number(delaySecTotal));
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- delayInfo->setText(msg);
|
|
|
-}
|
|
|
+ if (!statusWidget->ui->delayFrame->isVisible())
|
|
|
+ statusWidget->ui->delayFrame->show();
|
|
|
|
|
|
-#define BITRATE_UPDATE_SECONDS 2
|
|
|
+ statusWidget->ui->delayInfo->setText(msg);
|
|
|
+ }
|
|
|
+}
|
|
|
|
|
|
void OBSBasicStatusBar::UpdateBandwidth()
|
|
|
{
|
|
|
if (!streamOutput)
|
|
|
return;
|
|
|
|
|
|
- if (++bitrateUpdateSeconds < BITRATE_UPDATE_SECONDS)
|
|
|
+ if (++seconds < bitrateUpdateSeconds)
|
|
|
return;
|
|
|
|
|
|
uint64_t bytesSent = obs_output_get_total_bytes(streamOutput);
|
|
|
@@ -215,14 +202,18 @@ void OBSBasicStatusBar::UpdateBandwidth()
|
|
|
double kbitsPerSec = double(bitsBetween) / timePassed / 1000.0;
|
|
|
|
|
|
QString text;
|
|
|
- text += QString("kb/s: ") + QString::number(kbitsPerSec, 'f', 0);
|
|
|
+ text += QString::number(kbitsPerSec, 'f', 0) + QString(" kbps");
|
|
|
+
|
|
|
+ statusWidget->ui->kbps->setText(text);
|
|
|
+ statusWidget->ui->kbps->setMinimumWidth(
|
|
|
+ statusWidget->ui->kbps->width());
|
|
|
|
|
|
- kbps->setText(text);
|
|
|
- kbps->setMinimumWidth(kbps->width());
|
|
|
+ if (!statusWidget->ui->kbps->isVisible())
|
|
|
+ statusWidget->ui->kbps->show();
|
|
|
|
|
|
lastBytesSent = bytesSent;
|
|
|
lastBytesSentTime = bytesSentTime;
|
|
|
- bitrateUpdateSeconds = 0;
|
|
|
+ seconds = 0;
|
|
|
}
|
|
|
|
|
|
void OBSBasicStatusBar::UpdateCPUUsage()
|
|
|
@@ -233,11 +224,34 @@ void OBSBasicStatusBar::UpdateCPUUsage()
|
|
|
|
|
|
QString text;
|
|
|
text += QString("CPU: ") +
|
|
|
- QString::number(main->GetCPUUsage(), 'f', 1) + QString("%, ") +
|
|
|
- QString::number(obs_get_active_fps(), 'f', 2) + QString(" fps");
|
|
|
+ QString::number(main->GetCPUUsage(), 'f', 1) + QString("%");
|
|
|
+
|
|
|
+ statusWidget->ui->cpuUsage->setText(text);
|
|
|
+ statusWidget->ui->cpuUsage->setMinimumWidth(
|
|
|
+ statusWidget->ui->cpuUsage->width());
|
|
|
|
|
|
- cpuUsage->setText(text);
|
|
|
- cpuUsage->setMinimumWidth(cpuUsage->width());
|
|
|
+ UpdateCurrentFPS();
|
|
|
+}
|
|
|
+
|
|
|
+void OBSBasicStatusBar::UpdateCurrentFPS()
|
|
|
+{
|
|
|
+ OBSBasic *main = qobject_cast<OBSBasic *>(parent());
|
|
|
+ if (!main)
|
|
|
+ return;
|
|
|
+
|
|
|
+ struct obs_video_info ovi;
|
|
|
+ obs_get_video_info(&ovi);
|
|
|
+ float targetFPS = (float)ovi.fps_num / (float)ovi.fps_den;
|
|
|
+
|
|
|
+ QString text;
|
|
|
+ text += QString::number(obs_get_active_fps(), 'f', 2);
|
|
|
+ text += QString(" / ");
|
|
|
+ text += QString::number(targetFPS, 'f', 2);
|
|
|
+ text += QString(" FPS");
|
|
|
+
|
|
|
+ statusWidget->ui->fpsCurrent->setText(text);
|
|
|
+ statusWidget->ui->fpsCurrent->setMinimumWidth(
|
|
|
+ statusWidget->ui->fpsCurrent->width());
|
|
|
}
|
|
|
|
|
|
void OBSBasicStatusBar::UpdateStreamTime()
|
|
|
@@ -249,16 +263,20 @@ void OBSBasicStatusBar::UpdateStreamTime()
|
|
|
int minutes = totalMinutes % 60;
|
|
|
int hours = totalMinutes / 60;
|
|
|
|
|
|
- QString text = QString::asprintf("LIVE: %02d:%02d:%02d", hours, minutes,
|
|
|
- seconds);
|
|
|
- streamTime->setText(text);
|
|
|
- streamTime->setMinimumWidth(streamTime->width());
|
|
|
+ QString text =
|
|
|
+ QString::asprintf("%02d:%02d:%02d", hours, minutes, seconds);
|
|
|
+ statusWidget->ui->streamTime->setText(text);
|
|
|
+ if (streamOutput && !statusWidget->ui->streamTime->isEnabled())
|
|
|
+ statusWidget->ui->streamTime->setDisabled(false);
|
|
|
|
|
|
if (reconnectTimeout > 0) {
|
|
|
QString msg = QTStr("Basic.StatusBar.Reconnecting")
|
|
|
.arg(QString::number(retries),
|
|
|
QString::number(reconnectTimeout));
|
|
|
showMessage(msg);
|
|
|
+ disconnected = true;
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(disconnectedPixmap);
|
|
|
+ congestionArray.clear();
|
|
|
reconnectTimeout--;
|
|
|
|
|
|
} else if (retries > 0) {
|
|
|
@@ -289,14 +307,15 @@ void OBSBasicStatusBar::UpdateRecordTime()
|
|
|
int minutes = totalMinutes % 60;
|
|
|
int hours = totalMinutes / 60;
|
|
|
|
|
|
- QString text = QString::asprintf("REC: %02d:%02d:%02d", hours,
|
|
|
+ QString text = QString::asprintf("%02d:%02d:%02d", hours,
|
|
|
minutes, seconds);
|
|
|
|
|
|
- recordTime->setText(text);
|
|
|
- recordTime->setMinimumWidth(recordTime->width());
|
|
|
+ statusWidget->ui->recordTime->setText(text);
|
|
|
+ if (recordOutput && !statusWidget->ui->recordTime->isEnabled())
|
|
|
+ statusWidget->ui->recordTime->setDisabled(false);
|
|
|
} else {
|
|
|
- recordIcon->setPixmap(streamPauseIconToggle
|
|
|
- ? recordingPauseInactivePixmap
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(
|
|
|
+ streamPauseIconToggle ? recordingPauseInactivePixmap
|
|
|
: recordingPausePixmap);
|
|
|
|
|
|
streamPauseIconToggle = !streamPauseIconToggle;
|
|
|
@@ -318,8 +337,10 @@ void OBSBasicStatusBar::UpdateDroppedFrames()
|
|
|
QString text = QTStr("DroppedFrames");
|
|
|
text = text.arg(QString::number(totalDropped),
|
|
|
QString::number(percent, 'f', 1));
|
|
|
- droppedFrames->setText(text);
|
|
|
- droppedFrames->setMinimumWidth(droppedFrames->width());
|
|
|
+ statusWidget->ui->droppedFrames->setText(text);
|
|
|
+
|
|
|
+ if (!statusWidget->ui->issuesFrame->isVisible())
|
|
|
+ statusWidget->ui->issuesFrame->show();
|
|
|
|
|
|
/* ----------------------------------- *
|
|
|
* calculate congestion color */
|
|
|
@@ -331,28 +352,37 @@ void OBSBasicStatusBar::UpdateDroppedFrames()
|
|
|
if (avgCongestion > 1.0f)
|
|
|
avgCongestion = 1.0f;
|
|
|
|
|
|
- if (avgCongestion < EPSILON) {
|
|
|
- statusSquare->setPixmap(greenPixmap);
|
|
|
- } else if (fabsf(avgCongestion - 1.0f) < EPSILON) {
|
|
|
- statusSquare->setPixmap(redPixmap);
|
|
|
- } else {
|
|
|
- QPixmap pixmap(20, 20);
|
|
|
+ lastCongestion = congestion;
|
|
|
|
|
|
- float red = avgCongestion * 2.0f;
|
|
|
- if (red > 1.0f)
|
|
|
- red = 1.0f;
|
|
|
- red *= 255.0;
|
|
|
+ if (disconnected)
|
|
|
+ return;
|
|
|
|
|
|
- float green = (1.0f - avgCongestion) * 2.0f;
|
|
|
- if (green > 1.0f)
|
|
|
- green = 1.0f;
|
|
|
- green *= 255.0;
|
|
|
+ bool update = firstCongestionUpdate;
|
|
|
+ float congestionOverTime = avgCongestion;
|
|
|
|
|
|
- pixmap.fill(QColor(int(red), int(green), 0));
|
|
|
- statusSquare->setPixmap(pixmap);
|
|
|
+ if (congestionArray.size() >= congestionUpdateSeconds) {
|
|
|
+ congestionOverTime = accumulate(congestionArray.begin(),
|
|
|
+ congestionArray.end(), 0.0f) /
|
|
|
+ (float)congestionArray.size();
|
|
|
+ congestionArray.clear();
|
|
|
+ update = true;
|
|
|
+ } else {
|
|
|
+ congestionArray.emplace_back(avgCongestion);
|
|
|
}
|
|
|
|
|
|
- lastCongestion = congestion;
|
|
|
+ if (update) {
|
|
|
+ if (congestionOverTime <= excellentThreshold + EPSILON)
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(
|
|
|
+ excellentPixmap);
|
|
|
+ else if (congestionOverTime <= goodThreshold)
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(goodPixmap);
|
|
|
+ else if (congestionOverTime <= mediocreThreshold)
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(mediocrePixmap);
|
|
|
+ else if (congestionOverTime <= badThreshold)
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(badPixmap);
|
|
|
+
|
|
|
+ firstCongestionUpdate = false;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
void OBSBasicStatusBar::OBSOutputReconnect(void *data, calldata_t *params)
|
|
|
@@ -395,7 +425,7 @@ void OBSBasicStatusBar::ReconnectClear()
|
|
|
{
|
|
|
retries = 0;
|
|
|
reconnectTimeout = 0;
|
|
|
- bitrateUpdateSeconds = -1;
|
|
|
+ seconds = -1;
|
|
|
lastBytesSent = 0;
|
|
|
lastBytesSentTime = os_gettime_ns();
|
|
|
delaySecTotal = 0;
|
|
|
@@ -414,6 +444,8 @@ void OBSBasicStatusBar::ReconnectSuccess()
|
|
|
if (streamOutput) {
|
|
|
delaySecTotal = obs_output_get_active_delay(streamOutput);
|
|
|
UpdateDelayMsg();
|
|
|
+ disconnected = false;
|
|
|
+ firstCongestionUpdate = true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -518,11 +550,12 @@ void OBSBasicStatusBar::RecordingStopped()
|
|
|
|
|
|
void OBSBasicStatusBar::RecordingPaused()
|
|
|
{
|
|
|
- QString text = recordTime->text() + QStringLiteral(" (PAUSED)");
|
|
|
- recordTime->setText(text);
|
|
|
+ QString text = statusWidget->ui->recordTime->text() +
|
|
|
+ QStringLiteral(" (PAUSED)");
|
|
|
+ statusWidget->ui->recordTime->setText(text);
|
|
|
|
|
|
if (recordOutput) {
|
|
|
- recordIcon->setPixmap(recordingPausePixmap);
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(recordingPausePixmap);
|
|
|
streamPauseIconToggle = true;
|
|
|
}
|
|
|
}
|
|
|
@@ -530,6 +563,53 @@ void OBSBasicStatusBar::RecordingPaused()
|
|
|
void OBSBasicStatusBar::RecordingUnpaused()
|
|
|
{
|
|
|
if (recordOutput) {
|
|
|
- recordIcon->setPixmap(recordingActivePixmap);
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(recordingActivePixmap);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static QPixmap GetPixmap(const QString &filename)
|
|
|
+{
|
|
|
+ bool darkTheme = obs_frontend_is_theme_dark();
|
|
|
+ QString path;
|
|
|
+
|
|
|
+ if (darkTheme) {
|
|
|
+ std::string darkPath;
|
|
|
+ QString themePath = QString("themes/Dark/") + filename;
|
|
|
+ GetDataFilePath(QT_TO_UTF8(themePath), darkPath);
|
|
|
+ path = QT_UTF8(darkPath.c_str());
|
|
|
+ } else {
|
|
|
+ path = QString(":/res/images/" + filename);
|
|
|
+ }
|
|
|
+
|
|
|
+ return QIcon(path).pixmap(QSize(16, 16));
|
|
|
+}
|
|
|
+
|
|
|
+void OBSBasicStatusBar::UpdateIcons()
|
|
|
+{
|
|
|
+ disconnectedPixmap = GetPixmap("network-disconnected.svg");
|
|
|
+ inactivePixmap = GetPixmap("network-inactive.svg");
|
|
|
+
|
|
|
+ streamingInactivePixmap = GetPixmap("streaming-inactive.svg");
|
|
|
+
|
|
|
+ recordingInactivePixmap = GetPixmap("recording-inactive.svg");
|
|
|
+ recordingPauseInactivePixmap =
|
|
|
+ GetPixmap("recording-pause-inactive.svg");
|
|
|
+
|
|
|
+ bool streaming = obs_frontend_streaming_active();
|
|
|
+
|
|
|
+ if (!streaming) {
|
|
|
+ statusWidget->ui->streamIcon->setPixmap(
|
|
|
+ streamingInactivePixmap);
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(inactivePixmap);
|
|
|
+ } else {
|
|
|
+ if (disconnected)
|
|
|
+ statusWidget->ui->statusIcon->setPixmap(
|
|
|
+ disconnectedPixmap);
|
|
|
}
|
|
|
+
|
|
|
+ bool recording = obs_frontend_recording_active();
|
|
|
+
|
|
|
+ if (!recording)
|
|
|
+ statusWidget->ui->recordIcon->setPixmap(
|
|
|
+ recordingInactivePixmap);
|
|
|
}
|
cg2121
