mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-09-20 04:42:18 +02:00
568 lines
15 KiB
C++
568 lines
15 KiB
C++
/******************************************************************************
|
|
Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
******************************************************************************/
|
|
|
|
#include <obs.hpp>
|
|
#include <util/util.hpp>
|
|
#include <QMessageBox>
|
|
#include <QVariant>
|
|
#include <QFileDialog>
|
|
#include <QStandardPaths>
|
|
#include <qt-wrappers.hpp>
|
|
#include "item-widget-helpers.hpp"
|
|
#include "window-basic-main.hpp"
|
|
#include "window-importer.hpp"
|
|
#include "window-namedialog.hpp"
|
|
|
|
using namespace std;
|
|
|
|
void EnumSceneCollections(std::function<bool(const char *, const char *)> &&cb)
|
|
{
|
|
char path[512];
|
|
os_glob_t *glob;
|
|
|
|
int ret = GetConfigPath(path, sizeof(path),
|
|
"obs-studio/basic/scenes/*.json");
|
|
if (ret <= 0) {
|
|
blog(LOG_WARNING, "Failed to get config path for scene "
|
|
"collections");
|
|
return;
|
|
}
|
|
|
|
if (os_glob(path, 0, &glob) != 0) {
|
|
blog(LOG_WARNING, "Failed to glob scene collections");
|
|
return;
|
|
}
|
|
|
|
for (size_t i = 0; i < glob->gl_pathc; i++) {
|
|
const char *filePath = glob->gl_pathv[i].path;
|
|
|
|
if (glob->gl_pathv[i].directory)
|
|
continue;
|
|
|
|
OBSDataAutoRelease data =
|
|
obs_data_create_from_json_file_safe(filePath, "bak");
|
|
std::string name = obs_data_get_string(data, "name");
|
|
|
|
/* if no name found, use the file name as the name
|
|
* (this only happens when switching to the new version) */
|
|
if (name.empty()) {
|
|
name = strrchr(filePath, '/') + 1;
|
|
name.resize(name.size() - 5);
|
|
}
|
|
|
|
if (!cb(name.c_str(), filePath))
|
|
break;
|
|
}
|
|
|
|
os_globfree(glob);
|
|
}
|
|
|
|
bool SceneCollectionExists(const char *findName)
|
|
{
|
|
bool found = false;
|
|
auto func = [&](const char *name, const char *) {
|
|
if (strcmp(name, findName) == 0) {
|
|
found = true;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EnumSceneCollections(func);
|
|
return found;
|
|
}
|
|
|
|
static bool GetSceneCollectionName(QWidget *parent, std::string &name,
|
|
std::string &file,
|
|
const char *oldName = nullptr)
|
|
{
|
|
bool rename = oldName != nullptr;
|
|
const char *title;
|
|
const char *text;
|
|
|
|
if (rename) {
|
|
title = Str("Basic.Main.RenameSceneCollection.Title");
|
|
text = Str("Basic.Main.AddSceneCollection.Text");
|
|
} else {
|
|
title = Str("Basic.Main.AddSceneCollection.Title");
|
|
text = Str("Basic.Main.AddSceneCollection.Text");
|
|
}
|
|
|
|
for (;;) {
|
|
bool success = NameDialog::AskForName(parent, title, text, name,
|
|
QT_UTF8(oldName));
|
|
if (!success) {
|
|
return false;
|
|
}
|
|
if (name.empty()) {
|
|
OBSMessageBox::warning(parent,
|
|
QTStr("NoNameEntered.Title"),
|
|
QTStr("NoNameEntered.Text"));
|
|
continue;
|
|
}
|
|
if (SceneCollectionExists(name.c_str())) {
|
|
OBSMessageBox::warning(parent,
|
|
QTStr("NameExists.Title"),
|
|
QTStr("NameExists.Text"));
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!GetUnusedSceneCollectionFile(name, file)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool OBSBasic::AddSceneCollection(bool create_new, const QString &qname)
|
|
{
|
|
std::string name;
|
|
std::string file;
|
|
|
|
if (qname.isEmpty()) {
|
|
if (!GetSceneCollectionName(this, name, file))
|
|
return false;
|
|
} else {
|
|
name = QT_TO_UTF8(qname);
|
|
if (SceneCollectionExists(name.c_str()))
|
|
return false;
|
|
|
|
if (!GetUnusedSceneCollectionFile(name, file)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto new_collection = [this, create_new](const std::string &file,
|
|
const std::string &name) {
|
|
SaveProjectNow();
|
|
|
|
config_set_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection", name.c_str());
|
|
config_set_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile", file.c_str());
|
|
|
|
if (create_new) {
|
|
CreateDefaultScene(false);
|
|
} else {
|
|
obs_reset_source_uuids();
|
|
}
|
|
|
|
SaveProjectNow();
|
|
RefreshSceneCollections();
|
|
};
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING);
|
|
|
|
new_collection(file, name);
|
|
|
|
blog(LOG_INFO, "Added scene collection '%s' (%s, %s.json)",
|
|
name.c_str(), create_new ? "clean" : "duplicate", file.c_str());
|
|
blog(LOG_INFO, "------------------------------------------------");
|
|
|
|
UpdateTitleBar();
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED);
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED);
|
|
|
|
return true;
|
|
}
|
|
|
|
void OBSBasic::RefreshSceneCollections()
|
|
{
|
|
QList<QAction *> menuActions = ui->sceneCollectionMenu->actions();
|
|
int count = 0;
|
|
|
|
for (int i = 0; i < menuActions.count(); i++) {
|
|
QVariant v = menuActions[i]->property("file_name");
|
|
if (v.typeName() != nullptr)
|
|
delete menuActions[i];
|
|
}
|
|
|
|
const char *cur_name = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
|
|
auto addCollection = [&](const char *name, const char *path) {
|
|
std::string file = strrchr(path, '/') + 1;
|
|
file.erase(file.size() - 5, 5);
|
|
|
|
QAction *action = new QAction(QT_UTF8(name), this);
|
|
action->setProperty("file_name", QT_UTF8(path));
|
|
connect(action, &QAction::triggered, this,
|
|
&OBSBasic::ChangeSceneCollection);
|
|
action->setCheckable(true);
|
|
|
|
action->setChecked(strcmp(name, cur_name) == 0);
|
|
|
|
ui->sceneCollectionMenu->addAction(action);
|
|
count++;
|
|
return true;
|
|
};
|
|
|
|
EnumSceneCollections(addCollection);
|
|
|
|
/* force saving of first scene collection on first run, otherwise
|
|
* no scene collections will show up */
|
|
if (!count) {
|
|
long prevDisableVal = disableSaving;
|
|
|
|
disableSaving = 0;
|
|
SaveProjectNow();
|
|
disableSaving = prevDisableVal;
|
|
|
|
EnumSceneCollections(addCollection);
|
|
}
|
|
|
|
ui->actionRemoveSceneCollection->setEnabled(count > 1);
|
|
|
|
OBSBasic *main = reinterpret_cast<OBSBasic *>(App()->GetMainWindow());
|
|
|
|
main->ui->actionPasteFilters->setEnabled(false);
|
|
main->ui->actionPasteRef->setEnabled(false);
|
|
main->ui->actionPasteDup->setEnabled(false);
|
|
}
|
|
|
|
void OBSBasic::on_actionNewSceneCollection_triggered()
|
|
{
|
|
AddSceneCollection(true);
|
|
}
|
|
|
|
void OBSBasic::on_actionDupSceneCollection_triggered()
|
|
{
|
|
AddSceneCollection(false);
|
|
}
|
|
|
|
void OBSBasic::on_actionRenameSceneCollection_triggered()
|
|
{
|
|
std::string name;
|
|
std::string file;
|
|
std::string oname;
|
|
|
|
std::string oldFile = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile");
|
|
const char *oldName = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
oname = std::string(oldName);
|
|
|
|
bool success = GetSceneCollectionName(this, name, file, oldName);
|
|
if (!success)
|
|
return;
|
|
|
|
config_set_string(App()->GlobalConfig(), "Basic", "SceneCollection",
|
|
name.c_str());
|
|
config_set_string(App()->GlobalConfig(), "Basic", "SceneCollectionFile",
|
|
file.c_str());
|
|
SaveProjectNow();
|
|
|
|
char path[512];
|
|
int ret = GetConfigPath(path, 512, "obs-studio/basic/scenes/");
|
|
if (ret <= 0) {
|
|
blog(LOG_WARNING, "Failed to get scene collection config path");
|
|
return;
|
|
}
|
|
|
|
oldFile.insert(0, path);
|
|
oldFile += ".json";
|
|
os_unlink(oldFile.c_str());
|
|
oldFile += ".bak";
|
|
os_unlink(oldFile.c_str());
|
|
|
|
blog(LOG_INFO, "------------------------------------------------");
|
|
blog(LOG_INFO, "Renamed scene collection to '%s' (%s.json)",
|
|
name.c_str(), file.c_str());
|
|
blog(LOG_INFO, "------------------------------------------------");
|
|
|
|
UpdateTitleBar();
|
|
RefreshSceneCollections();
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_RENAMED);
|
|
}
|
|
|
|
void OBSBasic::on_actionRemoveSceneCollection_triggered()
|
|
{
|
|
std::string newName;
|
|
std::string newPath;
|
|
|
|
std::string oldFile = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile");
|
|
std::string oldName = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
|
|
auto cb = [&](const char *name, const char *filePath) {
|
|
if (strcmp(oldName.c_str(), name) != 0) {
|
|
newName = name;
|
|
newPath = filePath;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EnumSceneCollections(cb);
|
|
|
|
/* this should never be true due to menu item being grayed out */
|
|
if (newPath.empty())
|
|
return;
|
|
|
|
QString text =
|
|
QTStr("ConfirmRemove.Text").arg(QT_UTF8(oldName.c_str()));
|
|
|
|
QMessageBox::StandardButton button = OBSMessageBox::question(
|
|
this, QTStr("ConfirmRemove.Title"), text);
|
|
if (button == QMessageBox::No)
|
|
return;
|
|
|
|
char path[512];
|
|
int ret = GetConfigPath(path, 512, "obs-studio/basic/scenes/");
|
|
if (ret <= 0) {
|
|
blog(LOG_WARNING, "Failed to get scene collection config path");
|
|
return;
|
|
}
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING);
|
|
|
|
oldFile.insert(0, path);
|
|
/* os_rename() overwrites if necessary, only the .bak file will remain. */
|
|
os_rename((oldFile + ".json").c_str(), (oldFile + ".json.bak").c_str());
|
|
|
|
Load(newPath.c_str());
|
|
RefreshSceneCollections();
|
|
|
|
const char *newFile = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile");
|
|
|
|
blog(LOG_INFO,
|
|
"Removed scene collection '%s' (%s.json), "
|
|
"switched to '%s' (%s.json)",
|
|
oldName.c_str(), oldFile.c_str(), newName.c_str(), newFile);
|
|
blog(LOG_INFO, "------------------------------------------------");
|
|
|
|
UpdateTitleBar();
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_LIST_CHANGED);
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED);
|
|
}
|
|
|
|
void OBSBasic::on_actionImportSceneCollection_triggered()
|
|
{
|
|
OBSImporter imp(this);
|
|
imp.exec();
|
|
|
|
RefreshSceneCollections();
|
|
}
|
|
|
|
void OBSBasic::on_actionExportSceneCollection_triggered()
|
|
{
|
|
SaveProjectNow();
|
|
|
|
char path[512];
|
|
|
|
QString home = QDir::homePath();
|
|
|
|
QString currentFile = QT_UTF8(config_get_string(
|
|
App()->GlobalConfig(), "Basic", "SceneCollectionFile"));
|
|
|
|
int ret = GetConfigPath(path, 512, "obs-studio/basic/scenes/");
|
|
if (ret <= 0) {
|
|
blog(LOG_WARNING, "Failed to get scene collection config path");
|
|
return;
|
|
}
|
|
|
|
QString exportFile =
|
|
SaveFile(this, QTStr("Basic.MainMenu.SceneCollection.Export"),
|
|
home + "/" + currentFile, "JSON Files (*.json)");
|
|
|
|
string file = QT_TO_UTF8(exportFile);
|
|
|
|
if (!exportFile.isEmpty() && !exportFile.isNull()) {
|
|
QString inputFile = path + currentFile + ".json";
|
|
|
|
OBSDataAutoRelease collection =
|
|
obs_data_create_from_json_file(QT_TO_UTF8(inputFile));
|
|
|
|
OBSDataArrayAutoRelease sources =
|
|
obs_data_get_array(collection, "sources");
|
|
if (!sources) {
|
|
blog(LOG_WARNING,
|
|
"No sources in exported scene collection");
|
|
return;
|
|
}
|
|
obs_data_erase(collection, "sources");
|
|
|
|
// We're just using std::sort on a vector to make life easier.
|
|
vector<OBSData> sourceItems;
|
|
obs_data_array_enum(
|
|
sources,
|
|
[](obs_data_t *data, void *pVec) -> void {
|
|
auto &sourceItems =
|
|
*static_cast<vector<OBSData> *>(pVec);
|
|
sourceItems.push_back(data);
|
|
},
|
|
&sourceItems);
|
|
|
|
std::sort(sourceItems.begin(), sourceItems.end(),
|
|
[](const OBSData &a, const OBSData &b) {
|
|
return astrcmpi(obs_data_get_string(a,
|
|
"name"),
|
|
obs_data_get_string(
|
|
b, "name")) < 0;
|
|
});
|
|
|
|
OBSDataArrayAutoRelease newSources = obs_data_array_create();
|
|
for (auto &item : sourceItems)
|
|
obs_data_array_push_back(newSources, item);
|
|
|
|
obs_data_set_array(collection, "sources", newSources);
|
|
obs_data_save_json_pretty_safe(
|
|
collection, QT_TO_UTF8(exportFile), "tmp", "bak");
|
|
}
|
|
}
|
|
|
|
void OBSBasic::on_actionRemigrateSceneCollection_triggered()
|
|
{
|
|
if (Active()) {
|
|
OBSMessageBox::warning(
|
|
this,
|
|
QTStr("Basic.Main.RemigrateSceneCollection.Title"),
|
|
QTStr("Basic.Main.RemigrateSceneCollection.CannotMigrate.Active"));
|
|
return;
|
|
}
|
|
|
|
OBSDataAutoRelease priv = obs_get_private_data();
|
|
|
|
if (!usingAbsoluteCoordinates && !migrationBaseResolution) {
|
|
OBSMessageBox::warning(
|
|
this,
|
|
QTStr("Basic.Main.RemigrateSceneCollection.Title"),
|
|
QTStr("Basic.Main.RemigrateSceneCollection.CannotMigrate.UnknownBaseResolution"));
|
|
return;
|
|
}
|
|
|
|
obs_video_info ovi;
|
|
obs_get_video_info(&ovi);
|
|
|
|
if (!usingAbsoluteCoordinates &&
|
|
migrationBaseResolution->first == ovi.base_width &&
|
|
migrationBaseResolution->second == ovi.base_height) {
|
|
OBSMessageBox::warning(
|
|
this,
|
|
QTStr("Basic.Main.RemigrateSceneCollection.Title"),
|
|
QTStr("Basic.Main.RemigrateSceneCollection.CannotMigrate.BaseResolutionMatches"));
|
|
return;
|
|
}
|
|
|
|
QString name = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
QString message = QTStr("Basic.Main.RemigrateSceneCollection.Text")
|
|
.arg(name)
|
|
.arg(ovi.base_width)
|
|
.arg(ovi.base_height);
|
|
|
|
auto answer = OBSMessageBox::question(
|
|
this, QTStr("Basic.Main.RemigrateSceneCollection.Title"),
|
|
message);
|
|
|
|
if (answer == QMessageBox::No)
|
|
return;
|
|
|
|
lastOutputResolution = {ovi.base_width, ovi.base_height};
|
|
|
|
if (!usingAbsoluteCoordinates) {
|
|
/* Temporarily change resolution to migration resolution */
|
|
ovi.base_width = migrationBaseResolution->first;
|
|
ovi.base_height = migrationBaseResolution->second;
|
|
|
|
if (obs_reset_video(&ovi) != OBS_VIDEO_SUCCESS) {
|
|
OBSMessageBox::critical(
|
|
this,
|
|
QTStr("Basic.Main.RemigrateSceneCollection.Title"),
|
|
QTStr("Basic.Main.RemigrateSceneCollection.CannotMigrate.FailedVideoReset"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
char path[512];
|
|
int ret = GetConfigPath(path, 512, "obs-studio/basic/scenes/");
|
|
if (ret <= 0) {
|
|
blog(LOG_WARNING, "Failed to get scene collection config path");
|
|
return;
|
|
}
|
|
|
|
std::string fileName = path;
|
|
fileName += config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile");
|
|
fileName += ".json";
|
|
|
|
if (api)
|
|
api->on_event(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING);
|
|
|
|
/* Save and immediately reload to (re-)run migrations. */
|
|
SaveProjectNow();
|
|
/* Reset video if we potentially changed to a temporary resolution */
|
|
if (!usingAbsoluteCoordinates)
|
|
ResetVideo();
|
|
|
|
Load(fileName.c_str(), !usingAbsoluteCoordinates);
|
|
RefreshSceneCollections();
|
|
|
|
if (api)
|
|
api->on_event(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED);
|
|
}
|
|
|
|
void OBSBasic::ChangeSceneCollection()
|
|
{
|
|
QAction *action = reinterpret_cast<QAction *>(sender());
|
|
std::string fileName;
|
|
|
|
if (!action)
|
|
return;
|
|
|
|
fileName = QT_TO_UTF8(action->property("file_name").value<QString>());
|
|
if (fileName.empty())
|
|
return;
|
|
|
|
const char *oldName = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
|
|
if (action->text().compare(QT_UTF8(oldName)) == 0) {
|
|
action->setChecked(true);
|
|
return;
|
|
}
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGING);
|
|
|
|
SaveProjectNow();
|
|
|
|
Load(fileName.c_str());
|
|
RefreshSceneCollections();
|
|
|
|
const char *newName = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollection");
|
|
const char *newFile = config_get_string(App()->GlobalConfig(), "Basic",
|
|
"SceneCollectionFile");
|
|
|
|
blog(LOG_INFO, "Switched to scene collection '%s' (%s.json)", newName,
|
|
newFile);
|
|
blog(LOG_INFO, "------------------------------------------------");
|
|
|
|
UpdateTitleBar();
|
|
|
|
OnEvent(OBS_FRONTEND_EVENT_SCENE_COLLECTION_CHANGED);
|
|
}
|