Leahnaya/SceneSwitcher
1
0
Fork 0
mirror of https://github.com/WarmUpTill/SceneSwitcher.git synced 2026-03-22 01:44:49 -05:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Adjust to Duration rework

Browse Source
This commit is contained in:
WarmUpTill 2023-03-11 00:55:48 +01:00 committed by WarmUpTill
parent fcb3e648d2
commit b28c2b28b2
38 changed files with 194 additions and 372 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/advanced-scene-switcher.hpp
View File

@ -112,10 +112,8 @@ public slots:
void on_noMatchDontSwitch_clicked();
void on_noMatchSwitch_clicked();
void on_noMatchRandomSwitch_clicked();
void NoMatchDelayDurationChanged(double);
void NoMatchDelayUnitChanged(DurationUnit);
void CooldownDurationChanged(double);
void CooldownUnitChanged(DurationUnit);
void NoMatchDelayDurationChanged(const Duration &);
void CooldownDurationChanged(const Duration &);
void on_startupBehavior_currentIndexChanged(int index);
void on_autoStartEvent_currentIndexChanged(int index);
void on_noMatchSwitchScene_currentTextChanged(const QString &text);

50
src/general.cpp
View File

@ -60,44 +60,24 @@ void AdvSceneSwitcher::on_noMatchRandomSwitch_clicked()
ui->randomDisabledWarning->setVisible(false);
}
void AdvSceneSwitcher::NoMatchDelayDurationChanged(double sec)
void AdvSceneSwitcher::NoMatchDelayDurationChanged(const Duration &dur)
{
if (loading) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switcher->noMatchDelay.seconds = sec;
switcher->noMatchDelay = dur;
}
void AdvSceneSwitcher::NoMatchDelayUnitChanged(DurationUnit unit)
void AdvSceneSwitcher::CooldownDurationChanged(const Duration &dur)
{
if (loading) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switcher->noMatchDelay.displayUnit = unit;
}
void AdvSceneSwitcher::CooldownDurationChanged(double sec)
{
if (loading) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switcher->cooldown.seconds = sec;
}
void AdvSceneSwitcher::CooldownUnitChanged(DurationUnit unit)
{
if (loading) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switcher->cooldown.displayUnit = unit;
switcher->cooldown = dur;
}
void AdvSceneSwitcher::on_startupBehavior_currentIndexChanged(int index)
@ -622,9 +602,9 @@ void SwitcherData::saveGeneralSettings(obs_data_t *obj)
obs_data_set_string(obj, "non_matching_scene",
nonMatchingSceneName.c_str());
obs_data_set_int(obj, "switch_if_not_matching", switchIfNotMatching);
noMatchDelay.Save(obj, "noMatchDelay", "noMatchDelayUnit");
noMatchDelay.Save(obj, "noMatchDelay");
cooldown.Save(obj, "cooldown", "cooldownUnit");
cooldown.Save(obj, "cooldown");
obs_data_set_bool(obj, "active", sceneColletionStop ? true : !stop);
sceneColletionStop = false;
@ -672,9 +652,9 @@ void SwitcherData::loadGeneralSettings(obs_data_t *obj)
std::string nonMatchingSceneName =
obs_data_get_string(obj, "non_matching_scene");
nonMatchingScene = GetWeakSourceByName(nonMatchingSceneName.c_str());
noMatchDelay.Load(obj, "noMatchDelay", "noMatchDelayUnit");
noMatchDelay.Load(obj, "noMatchDelay");
cooldown.Load(obj, "cooldown", "cooldownUnit");
cooldown.Load(obj, "cooldown");
stop = !obs_data_get_bool(obj, "active");
startupBehavior =
@ -970,10 +950,9 @@ void AdvSceneSwitcher::setupGeneralTab()
noMatchDelay->setToolTip(obs_module_text(
"AdvSceneSwitcher.generalTab.generalBehavior.onNoMetDelayTooltip"));
ui->noMatchLayout->addWidget(noMatchDelay);
QWidget::connect(noMatchDelay, SIGNAL(DurationChanged(double)), this,
SLOT(NoMatchDelayDurationChanged(double)));
QWidget::connect(noMatchDelay, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(NoMatchDelayUnitChanged(DurationUnit)));
QWidget::connect(noMatchDelay,
SIGNAL(DurationChanged(const Duration &)), this,
SLOT(NoMatchDelayDurationChanged(const Duration &)));
ui->checkInterval->setValue(switcher->interval);
@ -983,10 +962,9 @@ void AdvSceneSwitcher::setupGeneralTab()
"AdvSceneSwitcher.generalTab.generalBehavior.cooldownHint"));
ui->cooldownLayout->addWidget(cooldownTime);
ui->cooldownLayout->addStretch();
QWidget::connect(cooldownTime, SIGNAL(DurationChanged(double)), this,
SLOT(CooldownDurationChanged(double)));
QWidget::connect(cooldownTime, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(CooldownUnitChanged(DurationUnit)));
QWidget::connect(cooldownTime,
SIGNAL(DurationChanged(const Duration &)), this,
SLOT(CooldownDurationChanged(const Duration &)));
ui->verboseLogging->setChecked(switcher->verbose);
ui->saveWindowGeo->setChecked(switcher->saveWindowGeo);

28
src/legacy/scene-trigger.cpp
View File

@ -156,7 +156,7 @@ void SceneTrigger::logMatch()
blog(LOG_INFO,
"scene '%s' in status '%s' triggering action '%s' after %f seconds",
GetWeakSourceName(scene).c_str(), statusName.c_str(),
actionName.c_str(), duration.seconds);
actionName.c_str(), duration.Seconds());
}
void frontEndActionThread(sceneTriggerAction action, double delay)
@ -266,14 +266,14 @@ void SceneTrigger::performAction()
if (isFrontendAction(triggerAction)) {
t = std::thread(frontEndActionThread, triggerAction,
duration.seconds);
duration.Seconds());
} else if (isAudioAction(triggerAction)) {
bool mute = triggerAction == sceneTriggerAction::MUTE_SOURCE;
t = std::thread(muteThread, audioSource, duration.seconds,
t = std::thread(muteThread, audioSource, duration.Seconds(),
mute);
} else if (isSwitcherStatusAction(triggerAction)) {
bool stop = triggerAction == sceneTriggerAction::STOP_SWITCHER;
t = std::thread(statusThread, duration.seconds, stop);
t = std::thread(statusThread, duration.Seconds(), stop);
} else {
blog(LOG_WARNING, "ignoring unknown action '%d'",
static_cast<int>(triggerAction));
@ -460,10 +460,8 @@ SceneTriggerWidget::SceneTriggerWidget(QWidget *parent, SceneTrigger *s)
SLOT(TriggerTypeChanged(int)));
QWidget::connect(actions, SIGNAL(currentIndexChanged(int)), this,
SLOT(TriggerActionChanged(int)));
QWidget::connect(duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(audioSources,
SIGNAL(currentTextChanged(const QString &)), this,
SLOT(AudioSourceChanged(const QString &)));
@ -552,24 +550,14 @@ void SceneTriggerWidget::TriggerActionChanged(int index)
}
}
void SceneTriggerWidget::DurationChanged(double seconds)
void SceneTriggerWidget::DurationChanged(const Duration &duration)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->duration.seconds = seconds;
}
void SceneTriggerWidget::DurationUnitChanged(DurationUnit unit)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->duration.displayUnit = unit;
switchData->duration = duration;
}
void SceneTriggerWidget::AudioSourceChanged(const QString &text)

3
src/legacy/scene-trigger.hpp
View File

@ -71,8 +71,7 @@ public:
private slots:
void TriggerTypeChanged(int index);
void TriggerActionChanged(int index);
void DurationChanged(double seconds);
void DurationUnitChanged(DurationUnit unit);
void DurationChanged(const Duration &);
void AudioSourceChanged(const QString &text);
private:

16
src/legacy/switch-audio.cpp
View File

@ -438,8 +438,8 @@ AudioSwitchWidget::AudioSwitchWidget(QWidget *parent, AudioSwitch *s)
SLOT(VolumeThresholdChanged(int)));
QWidget::connect(condition, SIGNAL(currentIndexChanged(int)), this,
SLOT(ConditionChanged(int)));
QWidget::connect(duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(audioSources,
SIGNAL(currentTextChanged(const QString &)), this,
SLOT(SourceChanged(const QString &)));
@ -554,14 +554,14 @@ void AudioSwitchWidget::ConditionChanged(int cond)
switchData->condition = (audioCondition)cond;
}
void AudioSwitchWidget::DurationChanged(double sec)
void AudioSwitchWidget::DurationChanged(const Duration &dur)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->duration.seconds = sec;
switchData->duration = dur;
}
void AudioSwitchWidget::IgnoreInactiveChanged(int state)
@ -580,8 +580,8 @@ AudioSwitchFallbackWidget::AudioSwitchFallbackWidget(QWidget *parent,
{
duration = new DurationSelection(this, false);
QWidget::connect(duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
if (s) {
duration->SetDuration(s->duration);
@ -602,12 +602,12 @@ AudioSwitchFallbackWidget::AudioSwitchFallbackWidget(QWidget *parent,
loading = false;
}
void AudioSwitchFallbackWidget::DurationChanged(double sec)
void AudioSwitchFallbackWidget::DurationChanged(const Duration &dur)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->duration.seconds = sec;
switchData->duration = dur;
}

4
src/legacy/switch-audio.hpp
View File

@ -75,7 +75,7 @@ private slots:
void SourceChanged(const QString &text);
void VolumeThresholdChanged(int vol);
void ConditionChanged(int cond);
void DurationChanged(double dur);
void DurationChanged(const Duration &);
void IgnoreInactiveChanged(int state);
private:
@ -96,7 +96,7 @@ public:
AudioSwitchFallbackWidget(QWidget *parent, AudioSwitchFallback *s);
private slots:
void DurationChanged(double dur);
void DurationChanged(const Duration &dur);
private:
DurationSelection *duration;

22
src/legacy/switch-sequence.cpp
View File

@ -455,7 +455,7 @@ bool SceneSequenceSwitch::checkDurationMatchInterruptible()
void SceneSequenceSwitch::prepareUninterruptibleMatch(int &linger)
{
int dur = delay.seconds * 1000;
int dur = delay.Milliseconds();
if (dur > 0) {
linger = dur;
}
@ -588,10 +588,8 @@ SequenceWidget::SequenceWidget(QWidget *parent, SceneSequenceSwitch *s,
QWidget::connect(scenes, SIGNAL(currentTextChanged(const QString &)),
this, SLOT(SceneChanged(const QString &)));
QWidget::connect(delay, SIGNAL(DurationChanged(double)), this,
SLOT(DelayChanged(double)));
QWidget::connect(delay, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DelayUnitsChanged(DurationUnit)));
QWidget::connect(delay, SIGNAL(DurationChanged(const Duration &)), this,
SLOT(DelayChanged(const Duration &)));
QWidget::connect(startScenes,
SIGNAL(currentTextChanged(const QString &)), this,
SLOT(StartSceneChanged(const QString &)));
@ -689,24 +687,14 @@ void SequenceWidget::swapSwitchData(SequenceWidget *s1, SequenceWidget *s2)
s2->setSwitchData(t);
}
void SequenceWidget::DelayChanged(double sec)
void SequenceWidget::DelayChanged(const Duration &delay)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->delay.seconds = sec;
}
void SequenceWidget::DelayUnitsChanged(DurationUnit unit)
{
if (loading || !switchData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
switchData->delay.displayUnit = unit;
switchData->delay = delay;
}
void SequenceWidget::setExtendedSequenceStartScene()

3
src/legacy/switch-sequence.hpp
View File

@ -59,8 +59,7 @@ public:
private slots:
void SceneChanged(const QString &text);
void DelayChanged(double delay);
void DelayUnitsChanged(DurationUnit);
void DelayChanged(const Duration &delay);
void StartSceneChanged(const QString &text);
void InterruptibleChanged(int state);
void ExtendClicked();

12
src/macro-core/macro-action-audio.cpp
View File

@ -114,7 +114,7 @@ void MacroActionAudio::FadeVolume()
int nrSteps = 0;
float volStep = 0.;
if (_fadeType == FadeType::DURATION) {
nrSteps = _duration.seconds * 1000 / fadeInterval.count();
nrSteps = _duration.Milliseconds() / fadeInterval.count();
volStep = volDiff / nrSteps;
} else {
volStep = _rate / 1000.0f;
@ -212,7 +212,7 @@ void MacroActionAudio::LogAction() const
vblog(LOG_INFO,
"performed action \"%s\" for source \"%s\" with volume %d with fade %d %f",
it->second.c_str(), _audioSource.ToString(true).c_str(),
_volume, _fade, _duration.seconds);
_volume, _fade, _duration.Seconds());
} else {
blog(LOG_WARNING, "ignored unknown audio action %d",
static_cast<int>(_action));
@ -353,8 +353,8 @@ MacroActionAudioEdit::MacroActionAudioEdit(
SLOT(VolumeChanged(int)));
QWidget::connect(_fade, SIGNAL(stateChanged(int)), this,
SLOT(FadeChanged(int)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_rate, SIGNAL(valueChanged(double)), this,
SLOT(RateChanged(double)));
QWidget::connect(_wait, SIGNAL(stateChanged(int)), this,
@ -556,14 +556,14 @@ void MacroActionAudioEdit::FadeChanged(int value)
SetWidgetVisibility();
}
void MacroActionAudioEdit::DurationChanged(double seconds)
void MacroActionAudioEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroActionAudioEdit::RateChanged(double value)

2
src/macro-core/macro-action-audio.hpp
View File

@ -89,7 +89,7 @@ private slots:
void BalanceChanged(double value);
void VolumeChanged(int value);
void FadeChanged(int value);
void DurationChanged(double seconds);
void DurationChanged(const Duration &seconds);
void RateChanged(double value);
void WaitChanged(int value);
void AbortActiveFadeChanged(int value);

12
src/macro-core/macro-action-http.cpp
View File

@ -45,7 +45,7 @@ void MacroActionHttp::Get()
{
switcher->curl.SetOpt(CURLOPT_URL, _url.c_str());
switcher->curl.SetOpt(CURLOPT_HTTPGET, 1L);
switcher->curl.SetOpt(CURLOPT_TIMEOUT_MS, _timeout.seconds * 1000);
switcher->curl.SetOpt(CURLOPT_TIMEOUT_MS, _timeout.Milliseconds());
SetupHeaders();
std::string response;
@ -64,7 +64,7 @@ void MacroActionHttp::Post()
{
switcher->curl.SetOpt(CURLOPT_URL, _url.c_str());
switcher->curl.SetOpt(CURLOPT_POSTFIELDS, _data.c_str());
switcher->curl.SetOpt(CURLOPT_TIMEOUT_MS, _timeout.seconds * 1000);
switcher->curl.SetOpt(CURLOPT_TIMEOUT_MS, _timeout.Milliseconds());
SetupHeaders();
switcher->curl.Perform();
}
@ -161,13 +161,13 @@ MacroActionHttpEdit::MacroActionHttpEdit(
SLOT(DataChanged()));
QWidget::connect(_methods, SIGNAL(currentIndexChanged(int)), this,
SLOT(MethodChanged(int)));
QWidget::connect(_timeout, SIGNAL(DurationChanged(double)), this,
SLOT(TimeoutChanged(double)));
QWidget::connect(_setHeaders, SIGNAL(stateChanged(int)), this,
SLOT(SetHeadersChanged(int)));
QWidget::connect(_headerList,
SIGNAL(StringListChanged(const StringList &)), this,
SLOT(HeadersChanged(const StringList &)));
QWidget::connect(_timeout, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(TimeoutChanged(const Duration &)));
std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
{"{{url}}", _url},
@ -238,14 +238,14 @@ void MacroActionHttpEdit::MethodChanged(int value)
SetWidgetVisibility();
}
void MacroActionHttpEdit::TimeoutChanged(double seconds)
void MacroActionHttpEdit::TimeoutChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_timeout.seconds = seconds;
_entryData->_timeout = dur;
}
void MacroActionHttpEdit::SetHeadersChanged(int value)

2
src/macro-core/macro-action-http.hpp
View File

@ -64,7 +64,7 @@ private slots:
void DataChanged();
void URLChanged();
void MethodChanged(int);
void TimeoutChanged(double seconds);
void TimeoutChanged(const Duration &seconds);
void SetHeadersChanged(int);
void HeadersChanged(const StringList &);
signals:

22
src/macro-core/macro-action-media.cpp
View File

@ -48,7 +48,7 @@ bool MacroActionMedia::PerformAction()
obs_source_media_previous(source);
break;
case MediaAction::SEEK:
obs_source_media_set_time(source, _seek.seconds * 1000);
obs_source_media_set_time(source, _seek.Milliseconds());
break;
default:
break;
@ -116,10 +116,8 @@ MacroActionMediaEdit::MacroActionMediaEdit(
QWidget::connect(_sources,
SIGNAL(SourceChanged(const SourceSelection &)), this,
SLOT(SourceChanged(const SourceSelection &)));
QWidget::connect(_seek, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_seek, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_seek, SIGNAL(DurationChanged(const Duration &)), this,
SLOT(DurationChanged(const Duration &)));
QHBoxLayout *mainLayout = new QHBoxLayout;
std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
@ -171,24 +169,14 @@ void MacroActionMediaEdit::ActionChanged(int value)
SetWidgetVisibility();
}
void MacroActionMediaEdit::DurationChanged(double seconds)
void MacroActionMediaEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_seek.seconds = seconds;
}
void MacroActionMediaEdit::DurationUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_seek.displayUnit = unit;
_entryData->_seek = dur;
}
void MacroActionMediaEdit::SetWidgetVisibility()

3
src/macro-core/macro-action-media.hpp
View File

@ -58,8 +58,7 @@ public:
private slots:
void SourceChanged(const SourceSelection &);
void ActionChanged(int value);
void DurationChanged(double value);
void DurationUnitChanged(DurationUnit unit);
void DurationChanged(const Duration &value);
signals:
void HeaderInfoChanged(const QString &);

12
src/macro-core/macro-action-scene-switch.cpp
View File

@ -103,7 +103,7 @@ bool MacroActionSwitchScene::WaitForTransition(OBSWeakSource &scene,
OBSWeakSource &transition)
{
const int expectedTransitionDuration = getExpectedTransitionDuration(
scene, transition, _duration.seconds);
scene, transition, _duration.Seconds());
switcher->abortMacroWait = false;
std::unique_lock<std::mutex> lock(switcher->m);
@ -121,7 +121,7 @@ bool MacroActionSwitchScene::PerformAction()
{
auto scene = _scene.GetScene();
auto transition = _transition.GetTransition();
switchScene({scene, transition, (int)(_duration.seconds * 1000)},
switchScene({scene, transition, (int)(_duration.Milliseconds())},
obs_frontend_preview_program_mode_active());
if (_blockUntilTransitionDone && scene) {
return WaitForTransition(scene, transition);
@ -196,8 +196,8 @@ MacroActionSwitchSceneEdit::MacroActionSwitchSceneEdit(
SIGNAL(TransitionChanged(const TransitionSelection &)),
this,
SLOT(TransitionChanged(const TransitionSelection &)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_blockUntilTransitionDone, SIGNAL(stateChanged(int)),
this, SLOT(BlockUntilTransitionDoneChanged(int)));
@ -225,14 +225,14 @@ MacroActionSwitchSceneEdit::MacroActionSwitchSceneEdit(
_loading = false;
}
void MacroActionSwitchSceneEdit::DurationChanged(double seconds)
void MacroActionSwitchSceneEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroActionSwitchSceneEdit::BlockUntilTransitionDoneChanged(int state)

2
src/macro-core/macro-action-scene-switch.hpp
View File

@ -51,7 +51,7 @@ public:
private slots:
void SceneChanged(const SceneSelection &);
void TransitionChanged(const TransitionSelection &);
void DurationChanged(double seconds);
void DurationChanged(const Duration &seconds);
void BlockUntilTransitionDoneChanged(int state);
signals:
void HeaderInfoChanged(const QString &);

22
src/macro-core/macro-action-timer.cpp
View File

@ -48,7 +48,7 @@ bool MacroActionTimer::PerformAction()
break;
case TimerAction::SET_TIME_REMAINING:
timerCondition->_duration.SetTimeRemaining(
_duration.seconds);
_duration.Seconds());
break;
default:
break;
@ -129,10 +129,8 @@ MacroActionTimerEdit::MacroActionTimerEdit(
QWidget::connect(_macros, SIGNAL(currentTextChanged(const QString &)),
this, SLOT(MacroChanged(const QString &)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_timerAction, SIGNAL(currentIndexChanged(int)), this,
SLOT(ActionTypeChanged(int)));
@ -185,24 +183,14 @@ void MacroActionTimerEdit::SetWidgetVisibility()
adjustSize();
}
void MacroActionTimerEdit::DurationChanged(double seconds)
void MacroActionTimerEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
}
void MacroActionTimerEdit::DurationUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.displayUnit = unit;
_entryData->_duration = dur;
}
void MacroActionTimerEdit::MacroChanged(const QString &text)

3
src/macro-core/macro-action-timer.hpp
View File

@ -52,8 +52,7 @@ public:
private slots:
void MacroChanged(const QString &text);
void DurationChanged(double value);
void DurationUnitChanged(DurationUnit unit);
void DurationChanged(const Duration &value);
void ActionTypeChanged(int value);
signals:
void HeaderInfoChanged(const QString &);

15
src/macro-core/macro-action-transition.cpp
View File

@ -29,7 +29,8 @@ void MacroActionTransition::SetSceneTransition()
obs_source_release(t);
}
if (_setDuration) {
obs_frontend_set_transition_duration(_duration.seconds * 1000);
obs_frontend_set_transition_duration(_duration.Seconds() *
1000);
}
}
@ -43,7 +44,7 @@ void MacroActionTransition::SetTransitionOverride()
}
if (_setDuration) {
obs_data_set_int(data, "transition_duration",
_duration.seconds * 1000);
_duration.Milliseconds());
}
obs_data_release(data);
obs_source_release(scene);
@ -91,7 +92,7 @@ void MacroActionTransition::SetSourceTransition(bool show)
}
if (_setDuration) {
obs_sceneitem_set_transition_duration(
item, show, _duration.seconds * 1000);
item, show, _duration.Milliseconds());
}
obs_sceneitem_release(item);
}
@ -230,8 +231,8 @@ MacroActionTransitionEdit::MacroActionTransitionEdit(
SIGNAL(TransitionChanged(const TransitionSelection &)),
this,
SLOT(TransitionChanged(const TransitionSelection &)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_setTransition, SIGNAL(stateChanged(int)), this,
SLOT(SetTransitionChanged(int)));
QWidget::connect(_setDuration, SIGNAL(stateChanged(int)), this,
@ -334,14 +335,14 @@ void MacroActionTransitionEdit::TransitionChanged(const TransitionSelection &t)
QString::fromStdString(_entryData->GetShortDesc()));
}
void MacroActionTransitionEdit::DurationChanged(double seconds)
void MacroActionTransitionEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroActionTransitionEdit::SetWidgetVisibility()

2
src/macro-core/macro-action-transition.hpp
View File

@ -70,7 +70,7 @@ private slots:
void SetTransitionChanged(int state);
void SetDurationChanged(int state);
void TransitionChanged(const TransitionSelection &);
void DurationChanged(double seconds);
void DurationChanged(const Duration &seconds);
signals:
void HeaderInfoChanged(const QString &);

66
src/macro-core/macro-action-wait.cpp
View File

@ -34,14 +34,14 @@ bool MacroActionWait::PerformAction()
{
double sleepDuration;
if (_waitType == WaitType::FIXED) {
sleepDuration = _duration.seconds;
sleepDuration = _duration.Seconds();
} else {
double min = (_duration.seconds < _duration2.seconds)
? _duration.seconds
: _duration2.seconds;
double max = (_duration.seconds < _duration2.seconds)
? _duration2.seconds
: _duration.seconds;
double min = (_duration.Seconds() < _duration2.Seconds())
? _duration.Seconds()
: _duration2.Seconds();
double max = (_duration.Seconds() < _duration2.Seconds())
? _duration2.Seconds()
: _duration.Seconds();
std::uniform_real_distribution<double> unif(min, max);
sleepDuration = unif(re);
}
@ -62,8 +62,9 @@ bool MacroActionWait::Save(obs_data_t *obj) const
{
MacroAction::Save(obj);
_duration.Save(obj);
_duration2.Save(obj, "seconds2", "displayUnit2");
_duration2.Save(obj, "duration2");
obs_data_set_int(obj, "waitType", static_cast<int>(_waitType));
obs_data_set_int(obj, "version", 1);
return true;
}
@ -71,7 +72,14 @@ bool MacroActionWait::Load(obs_data_t *obj)
{
MacroAction::Load(obj);
_duration.Load(obj);
_duration2.Load(obj, "seconds2", "displayUnit2");
// TODO: remove this fallback
if (obs_data_get_int(obj, "version") == 1) {
_duration2.Load(obj, "duration2");
} else {
_duration2.Load(obj, "seconds2");
_duration2.SetUnit(static_cast<Duration::Unit>(
obs_data_get_int(obj, "displayUnit2")));
}
_waitType = static_cast<WaitType>(obs_data_get_int(obj, "waitType"));
return true;
}
@ -93,14 +101,10 @@ MacroActionWaitEdit::MacroActionWaitEdit(
populateTypeSelection(_waitType);
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_duration2, SIGNAL(DurationChanged(double)), this,
SLOT(Duration2Changed(double)));
QWidget::connect(_duration2, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(Duration2UnitChanged(DurationUnit)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_duration2, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(Duration2Changed(const Duration &)));
QWidget::connect(_waitType, SIGNAL(currentIndexChanged(int)), this,
SLOT(TypeChanged(int)));
@ -180,42 +184,22 @@ void MacroActionWaitEdit::TypeChanged(int value)
_entryData->_waitType = type;
}
void MacroActionWaitEdit::DurationChanged(double seconds)
void MacroActionWaitEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroActionWaitEdit::DurationUnitChanged(DurationUnit unit)
void MacroActionWaitEdit::Duration2Changed(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.displayUnit = unit;
}
void MacroActionWaitEdit::Duration2Changed(double seconds)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration2.seconds = seconds;
}
void MacroActionWaitEdit::Duration2UnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration2.displayUnit = unit;
_entryData->_duration2 = dur;
}

6
src/macro-core/macro-action-wait.hpp
View File

@ -49,10 +49,8 @@ public:
}
private slots:
void DurationChanged(double value);
void DurationUnitChanged(DurationUnit unit);
void Duration2Changed(double value);
void Duration2UnitChanged(DurationUnit unit);
void DurationChanged(const Duration &value);
void Duration2Changed(const Duration &value);
void TypeChanged(int value);
protected:

24
src/macro-core/macro-condition-date.cpp
View File

@ -165,8 +165,8 @@ bool MacroConditionDate::CheckRegularDate(int64_t msSinceLastCheck)
}
if (match && _repeat) {
_dateTime = _dateTime.addSecs(_duration.seconds);
_dateTime2 = _dateTime2.addSecs(_duration.seconds);
_dateTime = _dateTime.addSecs(_duration.Seconds());
_dateTime2 = _dateTime2.addSecs(_duration.Seconds());
}
return match;
@ -398,10 +398,8 @@ MacroConditionDateEdit::MacroConditionDateEdit(
SLOT(RepeatChanged(int)));
QWidget::connect(_updateOnRepeat, SIGNAL(stateChanged(int)), this,
SLOT(UpdateOnRepeatChanged(int)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_advancedSettingsTooggle, SIGNAL(clicked()), this,
SLOT(AdvancedSettingsToggleClicked()));
QWidget::connect(_pattern, SIGNAL(editingFinished()), this,
@ -589,24 +587,14 @@ void MacroConditionDateEdit::UpdateOnRepeatChanged(int state)
_entryData->_updateOnRepeat = state;
}
void MacroConditionDateEdit::DurationChanged(double seconds)
void MacroConditionDateEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
}
void MacroConditionDateEdit::DurationUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.displayUnit = unit;
_entryData->_duration = dur;
}
void MacroConditionDateEdit::AdvancedSettingsToggleClicked()

3
src/macro-core/macro-condition-date.hpp
View File

@ -100,8 +100,7 @@ private slots:
void IgnoreTimeChanged(int state);
void RepeatChanged(int state);
void UpdateOnRepeatChanged(int state);
void DurationChanged(double seconds);
void DurationUnitChanged(DurationUnit unit);
void DurationChanged(const Duration &seconds);
void AdvancedSettingsToggleClicked();
void ShowNextMatch();
void UpdateCurrentTime();

25
src/macro-core/macro-condition-edit.cpp
View File

@ -129,8 +129,6 @@ DurationModifierEdit::DurationModifierEdit(QWidget *parent)
SLOT(_ModifierChanged(int)));
QObject::connect(_duration, &DurationSelection::DurationChanged, this,
&DurationModifierEdit::DurationChanged);
QObject::connect(_duration, &DurationSelection::UnitChanged, this,
&DurationModifierEdit::UnitChanged);
QWidget::connect(_toggle, SIGNAL(clicked()), this,
SLOT(ToggleClicked()));
@ -151,11 +149,6 @@ void DurationModifierEdit::SetValue(DurationModifier &value)
_duration->setVisible(value.GetType() != DurationModifier::Type::NONE);
}
void DurationModifierEdit::SetUnit(DurationUnit u)
{
_duration->SetUnit(u);
}
void DurationModifierEdit::SetDuration(const Duration &d)
{
_duration->SetDuration(d);
@ -196,10 +189,8 @@ MacroConditionEdit::MacroConditionEdit(
QWidget::connect(_conditionSelection,
SIGNAL(currentTextChanged(const QString &)), this,
SLOT(ConditionSelectionChanged(const QString &)));
QWidget::connect(_dur, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_dur, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_dur, SIGNAL(DurationChanged(const Duration &)), this,
SLOT(DurationChanged(const Duration &)));
QWidget::connect(_dur, SIGNAL(ModifierChanged(DurationModifier::Type)),
this,
SLOT(DurationModifierChanged(DurationModifier::Type)));
@ -325,7 +316,7 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
SetFocusPolicyOfWidgets();
}
void MacroConditionEdit::DurationChanged(double seconds)
void MacroConditionEdit::DurationChanged(const Duration &seconds)
{
if (_loading || !_entryData) {
return;
@ -345,16 +336,6 @@ void MacroConditionEdit::DurationModifierChanged(DurationModifier::Type m)
(*_entryData)->SetDurationModifier(m);
}
void MacroConditionEdit::DurationUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
(*_entryData)->SetDurationUnit(unit);
}
std::shared_ptr<MacroSegment> MacroConditionEdit::Data()
{
return *_entryData;

7
src/macro-core/macro-condition-edit.hpp
View File

@ -35,15 +35,13 @@ class DurationModifierEdit : public QWidget {
public:
DurationModifierEdit(QWidget *parent = nullptr);
void SetValue(DurationModifier &value);
void SetUnit(DurationUnit u);
void SetDuration(const Duration &d);
private slots:
void _ModifierChanged(int value);
void ToggleClicked();
signals:
void DurationChanged(double value);
void UnitChanged(DurationUnit u);
void DurationChanged(const Duration &value);
void ModifierChanged(DurationModifier::Type value);
private:
@ -69,9 +67,8 @@ public:
private slots:
void LogicSelectionChanged(int idx);
void ConditionSelectionChanged(const QString &text);
void DurationChanged(double seconds);
void DurationChanged(const Duration &value);
void DurationModifierChanged(DurationModifier::Type m);
void DurationUnitChanged(DurationUnit unit);
private:
void SetLogicSelection();

22
src/macro-core/macro-condition-idle.cpp
View File

@ -14,7 +14,7 @@ bool MacroConditionIdle::CheckCondition()
{
auto seconds = secondsSinceLastInput();
SetVariableValue(std::to_string(seconds));
return seconds >= _duration.seconds;
return seconds >= _duration.Seconds();
}
bool MacroConditionIdle::Save(obs_data_t *obj) const
@ -37,10 +37,8 @@ MacroConditionIdleEdit::MacroConditionIdleEdit(
{
_duration = new DurationSelection();
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QHBoxLayout *mainLayout = new QHBoxLayout;
std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
@ -55,24 +53,14 @@ MacroConditionIdleEdit::MacroConditionIdleEdit(
_loading = false;
}
void MacroConditionIdleEdit::DurationChanged(double seconds)
void MacroConditionIdleEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
}
void MacroConditionIdleEdit::DurationUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.displayUnit = unit;
_entryData->_duration = dur;
}
void MacroConditionIdleEdit::UpdateEntryData()

3
src/macro-core/macro-condition-idle.hpp
View File

@ -41,8 +41,7 @@ public:
}
private slots:
void DurationChanged(double seconds);
void DurationUnitChanged(DurationUnit unit);
void DurationChanged(const Duration &seconds);
protected:
DurationSelection *_duration;

31
src/macro-core/macro-condition-media.cpp
View File

@ -71,18 +71,18 @@ bool MacroConditionMedia::CheckTime()
match = true;
break;
case Time::TIME_RESTRICTION_SHORTER:
match = currentTime < _time.seconds * 1000;
match = currentTime < _time.Milliseconds();
break;
case Time::TIME_RESTRICTION_LONGER:
match = currentTime > _time.seconds * 1000;
match = currentTime > _time.Milliseconds();
break;
case Time::TIME_RESTRICTION_REMAINING_SHORTER:
match = duration > currentTime &&
duration - currentTime < _time.seconds * 1000;
duration - currentTime < _time.Milliseconds();
break;
case Time::TIME_RESTRICTION_REMAINING_LONGER:
match = duration > currentTime &&
duration - currentTime > _time.seconds * 1000;
duration - currentTime > _time.Milliseconds();
break;
default:
break;
@ -429,10 +429,8 @@ MacroConditionMediaEdit::MacroConditionMediaEdit(
SLOT(StateChanged(int)));
QWidget::connect(_timeRestrictions, SIGNAL(currentIndexChanged(int)),
this, SLOT(TimeRestrictionChanged(int)));
QWidget::connect(_time, SIGNAL(DurationChanged(double)), this,
SLOT(TimeChanged(double)));
QWidget::connect(_time, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(TimeUnitChanged(DurationUnit)));
QWidget::connect(_time, SIGNAL(DurationChanged(const Duration &)), this,
SLOT(TimeChanged(const Duration &)));
QWidget::connect(_onChange, SIGNAL(stateChanged(int)), this,
SLOT(OnChangeChanged(int)));
@ -560,27 +558,14 @@ void MacroConditionMediaEdit::TimeRestrictionChanged(int index)
}
}
void MacroConditionMediaEdit::TimeChanged(double seconds)
void MacroConditionMediaEdit::TimeChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_time.seconds = seconds;
if (_entryData->_sourceType != MacroConditionMedia::Type::SOURCE) {
_entryData->UpdateMediaSourcesOfSceneList();
}
}
void MacroConditionMediaEdit::TimeUnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_time.displayUnit = unit;
_entryData->_time = dur;
if (_entryData->_sourceType != MacroConditionMedia::Type::SOURCE) {
_entryData->UpdateMediaSourcesOfSceneList();
}

3
src/macro-core/macro-condition-media.hpp
View File

@ -116,8 +116,7 @@ private slots:
void SceneChanged(const SceneSelection &);
void StateChanged(int index);
void TimeRestrictionChanged(int index);
void TimeChanged(double seconds);
void TimeUnitChanged(DurationUnit unit);
void TimeChanged(const Duration &seconds);
void OnChangeChanged(int);
signals:
void HeaderInfoChanged(const QString &);

10
src/macro-core/macro-condition-run.cpp
View File

@ -61,7 +61,7 @@ void MacroConditionRun::RunProcess()
QString::fromStdString(_procConfig.WorkingDir()));
process.start(QString::fromStdString(_procConfig.Path()),
_procConfig.Args());
int timeout = _timeout.seconds * 1000;
int timeout = _timeout.Milliseconds();
vblog(LOG_INFO, "run \"%s\" with a timeout of %d ms",
_procConfig.Path().c_str(), timeout);
@ -134,8 +134,8 @@ MacroConditionRunEdit::MacroConditionRunEdit(
QWidget::connect(_procConfig,
SIGNAL(ConfigChanged(const ProcessConfig &)), this,
SLOT(ProcessConfigChanged(const ProcessConfig &)));
QWidget::connect(_timeout, SIGNAL(DurationChanged(double)), this,
SLOT(TimeoutChanged(double)));
QWidget::connect(_timeout, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(TimeoutChanged(const Duration &)));
QWidget::connect(_checkExitCode, SIGNAL(stateChanged(int)), this,
SLOT(CheckExitCodeChanged(int)));
QWidget::connect(_exitCode, SIGNAL(valueChanged(int)), this,
@ -177,14 +177,14 @@ void MacroConditionRunEdit::UpdateEntryData()
_exitCode->setValue(_entryData->_exitCode);
}
void MacroConditionRunEdit::TimeoutChanged(double seconds)
void MacroConditionRunEdit::TimeoutChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_timeout.seconds = seconds;
_entryData->_timeout = dur;
}
void MacroConditionRunEdit::CheckExitCodeChanged(int state)

2
src/macro-core/macro-condition-run.hpp
View File

@ -61,7 +61,7 @@ public:
private slots:
void ProcessConfigChanged(const ProcessConfig &);
void TimeoutChanged(double);
void TimeoutChanged(const Duration &);
void CheckExitCodeChanged(int);
void ExitCodeChanged(int);
signals:

66
src/macro-core/macro-condition-timer.cpp
View File

@ -35,12 +35,12 @@ bool MacroConditionTimer::CheckCondition()
void MacroConditionTimer::SetRandomTimeRemaining()
{
double min, max;
if (_duration.seconds <= _duration2.seconds) {
min = _duration.seconds;
max = _duration2.seconds;
if (_duration.Seconds() <= _duration2.Seconds()) {
min = _duration.Seconds();
max = _duration2.Seconds();
} else {
min = _duration2.seconds;
max = _duration.seconds;
min = _duration2.Seconds();
max = _duration.Seconds();
}
std::uniform_real_distribution<double> unif(min, max);
@ -53,17 +53,18 @@ bool MacroConditionTimer::Save(obs_data_t *obj) const
MacroCondition::Save(obj);
obs_data_set_int(obj, "type", static_cast<int>(_type));
_duration.Save(obj);
_duration2.Save(obj, "seconds2", "displayUnit2");
_duration2.Save(obj, "duration2");
if (_saveRemaining) {
obs_data_set_double(obj, "remaining",
_paused ? _remaining
: _duration.TimeRemaining());
} else {
obs_data_set_double(obj, "remaining", _duration.seconds);
obs_data_set_double(obj, "remaining", _duration.Seconds());
}
obs_data_set_bool(obj, "saveRemaining", _saveRemaining);
obs_data_set_bool(obj, "paused", _paused);
obs_data_set_bool(obj, "oneshot", _oneshot);
obs_data_set_int(obj, "version", 1);
return true;
}
@ -72,7 +73,14 @@ bool MacroConditionTimer::Load(obs_data_t *obj)
MacroCondition::Load(obj);
_type = static_cast<TimerType>(obs_data_get_int(obj, "type"));
_duration.Load(obj);
_duration2.Load(obj, "seconds2", "displayUnit2");
// TODO: remove this fallback
if (obs_data_get_int(obj, "version") == 1) {
_duration2.Load(obj, "duration2");
} else {
_duration2.Load(obj, "seconds2");
_duration2.SetUnit(static_cast<Duration::Unit>(
obs_data_get_int(obj, "displayUnit2")));
}
_remaining = obs_data_get_double(obj, "remaining");
_paused = obs_data_get_bool(obj, "paused");
_saveRemaining = obs_data_get_bool(obj, "saveRemaining");
@ -103,7 +111,7 @@ void MacroConditionTimer::Continue()
void MacroConditionTimer::Reset()
{
_remaining = _duration.seconds;
_remaining = _duration.Seconds();
_duration.Reset();
if (_type == TimerType::RANDOM) {
SetRandomTimeRemaining();
@ -136,14 +144,10 @@ MacroConditionTimerEdit::MacroConditionTimerEdit(
QWidget::connect(_timerTypes, SIGNAL(currentIndexChanged(int)), this,
SLOT(TimerTypeChanged(int)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(DurationUnitChanged(DurationUnit)));
QWidget::connect(_duration2, SIGNAL(DurationChanged(double)), this,
SLOT(Duration2Changed(double)));
QWidget::connect(_duration2, SIGNAL(UnitChanged(DurationUnit)), this,
SLOT(Duration2UnitChanged(DurationUnit)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QWidget::connect(_duration2, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(Duration2Changed(const Duration &)));
QWidget::connect(_pauseConinue, SIGNAL(clicked()), this,
SLOT(PauseContinueClicked()));
QWidget::connect(_reset, SIGNAL(clicked()), this, SLOT(ResetClicked()));
@ -201,44 +205,24 @@ void MacroConditionTimerEdit::TimerTypeChanged(int type)
SetWidgetVisibility();
}
void MacroConditionTimerEdit::DurationChanged(double seconds)
void MacroConditionTimerEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroConditionTimerEdit::DurationUnitChanged(DurationUnit unit)
void MacroConditionTimerEdit::Duration2Changed(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.displayUnit = unit;
}
void MacroConditionTimerEdit::Duration2Changed(double seconds)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration2.seconds = seconds;
}
void MacroConditionTimerEdit::Duration2UnitChanged(DurationUnit unit)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration2.displayUnit = unit;
_entryData->_duration2 = dur;
}
void MacroConditionTimerEdit::SaveRemainingChanged(int state)

6
src/macro-core/macro-condition-timer.hpp
View File

@ -63,10 +63,8 @@ public:
private slots:
void TimerTypeChanged(int type);
void DurationChanged(double seconds);
void DurationUnitChanged(DurationUnit unit);
void Duration2Changed(double seconds);
void Duration2UnitChanged(DurationUnit unit);
void DurationChanged(const Duration &seconds);
void Duration2Changed(const Duration &seconds);
void SaveRemainingChanged(int state);
void AutoResetChanged(int state);
void PauseContinueClicked();

10
src/macro-core/macro-condition-transition.cpp
View File

@ -70,7 +70,7 @@ bool MacroConditionTransition::CheckCondition()
break;
}
case TransitionCondition::DURATION:
ret = _duration.seconds * 1000 ==
ret = _duration.Milliseconds() ==
obs_frontend_get_transition_duration();
break;
case TransitionCondition::STARTED:
@ -198,8 +198,8 @@ MacroConditionTransitionEdit::MacroConditionTransitionEdit(
SLOT(TransitionChanged(const TransitionSelection &)));
QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
this, SLOT(SceneChanged(const SceneSelection &)));
QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
SLOT(DurationChanged(double)));
QWidget::connect(_duration, SIGNAL(DurationChanged(const Duration &)),
this, SLOT(DurationChanged(const Duration &)));
QHBoxLayout *mainLayout = new QHBoxLayout;
std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
@ -260,14 +260,14 @@ void MacroConditionTransitionEdit::SceneChanged(const SceneSelection &s)
_entryData->_scene = s;
}
void MacroConditionTransitionEdit::DurationChanged(double seconds)
void MacroConditionTransitionEdit::DurationChanged(const Duration &dur)
{
if (_loading || !_entryData) {
return;
}
std::lock_guard<std::mutex> lock(switcher->m);
_entryData->_duration.seconds = seconds;
_entryData->_duration = dur;
}
void MacroConditionTransitionEdit::SetWidgetVisibility()

2
src/macro-core/macro-condition-transition.hpp
View File

@ -68,7 +68,7 @@ private slots:
void ConditionChanged(int cond);
void TransitionChanged(const TransitionSelection &);
void SceneChanged(const SceneSelection &);
void DurationChanged(double seconds);
void DurationChanged(const Duration &seconds);
signals:
void HeaderInfoChanged(const QString &);

27
src/macro-core/macro-condition.cpp
View File

@ -12,24 +12,30 @@ const std::map<LogicType, LogicTypeInfo> MacroCondition::logicTypes = {
};
void DurationModifier::Save(obs_data_t *obj, const char *condName,
const char *secondsName, const char *unitName) const
const char *duration) const
{
obs_data_set_int(obj, condName, static_cast<int>(_type));
_dur.Save(obj, secondsName, unitName);
_dur.Save(obj, duration);
}
void DurationModifier::Load(obs_data_t *obj, const char *condName,
const char *secondsName, const char *unitName)
const char *duration)
{
// For backwards compatability check if duration value exist without
// time constraint condition - if so assume DurationCondition::MORE
if (!obs_data_has_user_value(obj, condName) &&
obs_data_has_user_value(obj, secondsName)) {
obs_data_has_user_value(obj, duration)) {
obs_data_set_int(obj, condName, static_cast<int>(Type::MORE));
}
_type = static_cast<Type>(obs_data_get_int(obj, condName));
_dur.Load(obj, secondsName, unitName);
_dur.Load(obj, duration);
// TODO: remove this fallback
if (obs_data_has_user_value(obj, "displayUnit")) {
_dur.SetUnit(static_cast<Duration::Unit>(
obs_data_get_int(obj, "displayUnit")));
}
}
bool DurationModifier::DurationReached()
@ -127,7 +133,7 @@ void MacroCondition::CheckDurationModifier(bool &val)
case DurationModifier::Type::WITHIN:
if (val) {
_duration.SetTimeRemaining(
_duration.GetDuration().seconds);
_duration.GetDuration().Seconds());
}
val = val || _duration.DurationReached();
break;
@ -141,14 +147,9 @@ void MacroCondition::SetDurationModifier(DurationModifier::Type m)
_duration.SetModifier(m);
}
void MacroCondition::SetDurationUnit(DurationUnit u)
void MacroCondition::SetDuration(const Duration &duration)
{
_duration.SetUnit(u);
}
void MacroCondition::SetDuration(double seconds)
{
_duration.SetValue(seconds);
_duration.SetValue(duration);
}
MacroRefCondition::MacroRefCondition(Macro *m, bool supportsVariableValue)

12
src/macro-core/macro-condition.hpp
View File

@ -39,15 +39,12 @@ public:
};
void Save(obs_data_t *obj, const char *condName = "time_constraint",
const char *secondsName = "seconds",
const char *unitName = "displayUnit") const;
const char *duration = "seconds") const;
void Load(obs_data_t *obj, const char *condName = "time_constraint",
const char *secondsName = "seconds",
const char *unitName = "displayUnit");
const char *duration = "seconds");
void SetModifier(Type cond) { _type = cond; }
void SetTimeRemaining(const double &val) { _dur.SetTimeRemaining(val); }
void SetValue(double value) { _dur.seconds = value; }
void SetUnit(DurationUnit u) { _dur.displayUnit = u; }
void SetValue(const Duration &value) { _dur = value; }
Type GetType() { return _type; }
Duration GetDuration() { return _dur; }
bool DurationReached();
@ -73,8 +70,7 @@ public:
void CheckDurationModifier(bool &val);
DurationModifier GetDurationModifier() { return _duration; }
void SetDurationModifier(DurationModifier::Type m);
void SetDurationUnit(DurationUnit u);
void SetDuration(double seconds);
void SetDuration(const Duration &duration);
private:
LogicType _logic = LogicType::ROOT_NONE;