Add generic time constraint to macro conditions

Almost every macro condition can benefit from having the option to
specify a time constraint.
Instead of adding it to each condition separately add it to all
conditions with the option of excluding it when registering a new
condition type.

data/locale/en-US.ini

@@ -479,3 +479,7 @@ AdvSceneSwitcher.unit.milliseconds="milliseconds"
 AdvSceneSwitcher.unit.secends="seconds"
 AdvSceneSwitcher.unit.minutes="minutes"
 AdvSceneSwitcher.unit.hours="hours"
+AdvSceneSwitcher.duration.condition.none="No time constraint"
+AdvSceneSwitcher.duration.condition.more="For at least"
+AdvSceneSwitcher.duration.condition.equal="For exactly"
+AdvSceneSwitcher.duration.condition.less="For at most"

src/duration-control.cpp

@@ -1,4 +1,5 @@
 #include "headers/duration-control.hpp"
+#include "headers/utility.hpp"
 #include "obs-module.h"
 
 #include <sstream>
@@ -99,6 +100,8 @@ DurationSelection::DurationSelection(QWidget *parent, bool showUnitSelection)
 			 SLOT(_UnitChanged(int)));
 
 	QHBoxLayout *layout = new QHBoxLayout;
+	layout->setContentsMargins(0, 0, 0, 0);
+	layout->setSpacing(11);
 	layout->addWidget(_duration);
 	if (showUnitSelection) {
 		layout->addWidget(_unitSelection);
@@ -137,3 +140,104 @@ void DurationSelection::_UnitChanged(int idx)
 
 	emit UnitChanged(unit);
 }
+
+void DurationConstraint::Save(obs_data_t *obj, const char *condName,
+			      const char *secondsName, const char *unitName)
+{
+	obs_data_set_int(obj, condName, static_cast<int>(_type));
+	_dur.Save(obj, secondsName, unitName);
+}
+
+void DurationConstraint::Load(obs_data_t *obj, const char *condName,
+			      const char *secondsName, const char *unitName)
+{
+	_type = static_cast<DurationCondition>(obs_data_get_int(obj, condName));
+	_dur.Load(obj, secondsName, unitName);
+}
+
+bool DurationConstraint::DurationReached()
+{
+	switch (_type) {
+	case DurationCondition::NONE:
+		return true;
+		break;
+	case DurationCondition::MORE:
+		return _dur.DurationReached();
+		break;
+	case DurationCondition::EQUAL:
+		if (_dur.DurationReached() && !_timeReached) {
+			_timeReached = true;
+			return true;
+		}
+		break;
+	case DurationCondition::LESS:
+		return !_dur.DurationReached();
+		break;
+	default:
+		break;
+	}
+	return false;
+}
+
+void DurationConstraint::Reset()
+{
+	_timeReached = false;
+	_dur.Reset();
+}
+
+static void populateConditions(QComboBox *list)
+{
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.none"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.more"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.equal"));
+	list->addItem(
+		obs_module_text("AdvSceneSwitcher.duration.condition.less"));
+}
+
+DurationConstraintEdit::DurationConstraintEdit(QWidget *parent)
+{
+	_condition = new QComboBox(parent);
+	_duration = new DurationSelection(parent);
+	populateConditions(_condition);
+	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(_ConditionChanged(int)));
+
+	QObject::connect(_duration, &DurationSelection::DurationChanged, this,
+			 &DurationConstraintEdit::DurationChanged);
+	QObject::connect(_duration, &DurationSelection::UnitChanged, this,
+			 &DurationConstraintEdit::UnitChanged);
+
+	QHBoxLayout *layout = new QHBoxLayout;
+	layout->setContentsMargins(0, 0, 0, 0);
+	layout->setSpacing(11);
+	layout->addWidget(_condition);
+	layout->addWidget(_duration);
+	setLayout(layout);
+}
+
+void DurationConstraintEdit::SetValue(DurationConstraint &value)
+{
+	_duration->SetDuration(value.GetDuration());
+	_condition->setCurrentIndex(static_cast<int>(value.GetCondition()));
+	_duration->setVisible(value.GetCondition() != DurationCondition::NONE);
+}
+
+void DurationConstraintEdit::SetUnit(DurationUnit u)
+{
+	_duration->SetUnit(u);
+}
+
+void DurationConstraintEdit::SetDuration(const Duration &d)
+{
+	_duration->SetDuration(d);
+}
+
+void DurationConstraintEdit::_ConditionChanged(int value)
+{
+	auto cond = static_cast<DurationCondition>(value);
+	_duration->setVisible(cond != DurationCondition::NONE);
+	emit ConditionChanged(cond);
+}

src/headers/duration-control.hpp

@@ -53,3 +53,53 @@ private:
 
 	double _unitMultiplier;
 };
+
+enum class DurationCondition {
+	NONE,
+	MORE,
+	EQUAL,
+	LESS,
+};
+
+class DurationConstraint {
+public:
+	void Save(obs_data_t *obj, const char *condName = "time_constraint",
+		  const char *secondsName = "seconds",
+		  const char *unitName = "displayUnit");
+	void Load(obs_data_t *obj, const char *condName = "time_constraint",
+		  const char *secondsName = "seconds",
+		  const char *unitName = "displayUnit");
+	void SetCondition(DurationCondition cond) { _type = cond; }
+	void SetDuration(const Duration &dur) { _dur = dur; }
+	void SetValue(double value) { _dur.seconds = value; }
+	void SetUnit(DurationUnit u) { _dur.displayUnit = u; }
+	DurationCondition GetCondition() { return _type; }
+	Duration GetDuration() { return _dur; }
+	bool DurationReached();
+	void Reset();
+
+private:
+	DurationCondition _type = DurationCondition::NONE;
+	Duration _dur;
+	bool _timeReached = false;
+};
+
+class DurationConstraintEdit : public QWidget {
+	Q_OBJECT
+public:
+	DurationConstraintEdit(QWidget *parent = nullptr);
+	void SetValue(DurationConstraint &value);
+	void SetUnit(DurationUnit u);
+	void SetDuration(const Duration &d);
+
+private slots:
+	void _ConditionChanged(int value);
+signals:
+	void DurationChanged(double value);
+	void UnitChanged(DurationUnit u);
+	void ConditionChanged(DurationCondition value);
+
+private:
+	DurationSelection *_duration;
+	QComboBox *_condition;
+};

src/headers/macro-condition-audio.hpp

@@ -6,8 +6,6 @@
 #include <QComboBox>
 #include <chrono>
 
-#include "duration-control.hpp"
-
 enum class AudioCondition {
 	ABOVE,
 	BELOW,
@@ -33,7 +31,6 @@ public:
 	OBSWeakSource _audioSource;
 	int _volume = 0;
 	AudioCondition _condition = AudioCondition::ABOVE;
-	Duration _duration;
 	obs_volmeter_t *_volmeter = nullptr;
 
 private:
@@ -63,13 +60,11 @@ private slots:
 	void SourceChanged(const QString &text);
 	void VolumeThresholdChanged(int vol);
 	void ConditionChanged(int cond);
-	void DurationChanged(double seconds);
 
 protected:
 	QComboBox *_audioSources;
 	QComboBox *_condition;
 	QSpinBox *_volume;
-	DurationSelection *_duration;
 	VolControl *_volMeter = nullptr;
 	std::shared_ptr<MacroConditionAudio> _entryData;
 

src/headers/macro-condition-edit.hpp

@@ -15,6 +15,7 @@ struct MacroConditionInfo {
 	TCreateMethod _createFunc;
 	TCreateWidgetMethod _createWidgetFunc;
 	std::string _name;
+	bool _useDurationConstraint = true;
 };
 
 class MacroConditionFactory {
@@ -27,6 +28,7 @@ public:
 	static auto GetConditionTypes() { return _methods; }
 	static std::string GetConditionName(const std::string &);
 	static std::string GetIdByName(const QString &name);
+	static bool UsesDurationConstraint(const std::string &id);
 
 private:
 	static std::map<std::string, MacroConditionInfo> _methods;
@@ -46,11 +48,15 @@ public:
 private slots:
 	void LogicSelectionChanged(int idx);
 	void ConditionSelectionChanged(const QString &text);
+	void DurationChanged(double seconds);
+	void DurationConditionChanged(DurationCondition cond);
+	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_logicSelection;
 	QComboBox *_conditionSelection;
 	Section *_section;
+	DurationConstraintEdit *_dur;
 
 	std::shared_ptr<MacroCondition> *_entryData;
 

src/headers/macro-condition-idle.hpp

@@ -1,8 +1,9 @@
 #pragma once
 #include "macro.hpp"
+#include "duration-control.hpp"
+
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 class MacroConditionIdle : public MacroCondition {
 public:

src/headers/macro-condition-recording.hpp

@@ -2,7 +2,6 @@
 #include "macro.hpp"
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class RecordState {
 	STOP,
@@ -22,7 +21,6 @@ public:
 	}
 
 	RecordState _recordState;
-	Duration _duration;
 
 private:
 	static bool _registered;
@@ -47,12 +45,9 @@ public:
 
 private slots:
 	void StateChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_recordState;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionRecord> _entryData;
 
 private:

src/headers/macro-condition-scene.hpp

@@ -2,7 +2,6 @@
 #include "macro.hpp"
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class SceneType {
 	CURRENT,
@@ -22,7 +21,6 @@ public:
 
 	OBSWeakSource _scene;
 	SceneType _type;
-	Duration _duration;
 
 private:
 	static bool _registered;
@@ -48,13 +46,10 @@ public:
 private slots:
 	void SceneChanged(const QString &text);
 	void TypeChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_sceneSelection;
 	QComboBox *_sceneType;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionScene> _entryData;
 
 private:

src/headers/macro-condition-streaming.hpp

@@ -2,7 +2,6 @@
 #include "macro.hpp"
 #include <QWidget>
 #include <QComboBox>
-#include "duration-control.hpp"
 
 enum class StreamState {
 	STOP,
@@ -21,7 +20,6 @@ public:
 	}
 
 	StreamState _streamState;
-	Duration _duration;
 
 private:
 	static bool _registered;
@@ -46,12 +44,9 @@ public:
 
 private slots:
 	void StateChanged(int value);
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_streamState;
-	DurationSelection *_duration;
 	std::shared_ptr<MacroConditionStream> _entryData;
 
 private:

src/headers/macro-condition-video.hpp

@@ -1,10 +1,10 @@
 #pragma once
 #include "macro.hpp"
+#include "screenshot-helper.hpp"
+
 #include <QWidget>
 #include <QComboBox>
 #include <chrono>
-#include "duration-control.hpp"
-#include "screenshot-helper.hpp"
 
 enum class VideoCondition {
 	MATCH,
@@ -30,7 +30,6 @@ public:
 
 	OBSWeakSource _videoSource;
 	VideoCondition _condition = VideoCondition::MATCH;
-	Duration _duration;
 	std::string _file = obs_module_text("AdvSceneSwitcher.enterPath");
 
 private:
@@ -66,12 +65,9 @@ private slots:
 	void ConditionChanged(int cond);
 	void FilePathChanged();
 	void BrowseButtonClicked();
-	void DurationChanged(double seconds);
-	void DurationUnitChanged(DurationUnit unit);
 
 protected:
 	QComboBox *_videoSelection;
-	DurationSelection *_duration;
 	QComboBox *_condition;
 	QLineEdit *_filePath;
 	QPushButton *_browseButton;

src/headers/macro.hpp

@@ -1,4 +1,6 @@
 #pragma once
+#include "duration-control.hpp"
+
 #include <string>
 #include <deque>
 #include <memory>
@@ -40,13 +42,22 @@ public:
 	virtual bool Save(obs_data_t *obj) = 0;
 	virtual bool Load(obs_data_t *obj) = 0;
 	virtual std::string GetId() = 0;
+
 	LogicType GetLogicType() { return _logic; }
 	void SetLogicType(LogicType logic) { _logic = logic; }
-
 	static const std::map<LogicType, LogicTypeInfo> logicTypes;
 
+	bool DurationReached() { return _duration.DurationReached(); }
+	void ResetDuration() { _duration.Reset(); }
+	DurationConstraint GetDurationConstraint() { return _duration; }
+	void SetDurationConstraint(const DurationConstraint &dur);
+	void SetDurationCondition(DurationCondition cond);
+	void SetDurationUnit(DurationUnit u);
+	void SetDuration(double seconds);
+
 private:
 	LogicType _logic;
+	DurationConstraint _duration;
 };
 
 class MacroAction {

src/macro-condition-audio.cpp

@@ -35,11 +35,7 @@ bool MacroConditionAudio::CheckCondition()
 	// Reset for next check
 	_peak = -std::numeric_limits<float>::infinity();
 
-	if (!volumeThresholdreached) {
-		_duration.Reset();
-		return false;
-	}
-	return _duration.DurationReached();
+	return volumeThresholdreached;
 }
 
 bool MacroConditionAudio::Save(obs_data_t *obj)
@@ -49,7 +45,6 @@ bool MacroConditionAudio::Save(obs_data_t *obj)
 			    GetWeakSourceName(_audioSource).c_str());
 	obs_data_set_int(obj, "volume", _volume);
 	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
-	_duration.Save(obj);
 	return true;
 }
 
@@ -75,12 +70,9 @@ bool MacroConditionAudio::Load(obs_data_t *obj)
 	MacroCondition::Load(obj);
 	const char *audioSourceName = obs_data_get_string(obj, "audioSource");
 	_audioSource = GetWeakSourceByName(audioSourceName);
-
 	_volume = obs_data_get_int(obj, "volume");
 	_condition =
 		static_cast<AudioCondition>(obs_data_get_int(obj, "condition"));
-	_duration.Load(obj);
-
 	_volmeter = AddVolmeterToSource(this, _audioSource);
 	return true;
 }
@@ -123,7 +115,6 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 	_audioSources = new QComboBox();
 	_condition = new QComboBox();
 	_volume = new QSpinBox();
-	_duration = new DurationSelection(parent, false);
 
 	_volume->setSuffix("%");
 	_volume->setMaximum(100);
@@ -133,8 +124,6 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 			 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(_audioSources,
 			 SIGNAL(currentTextChanged(const QString &)), this,
 			 SLOT(SourceChanged(const QString &)));
@@ -147,7 +136,7 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 		{"{{audioSources}}", _audioSources},
 		{"{{volume}}", _volume},
 		{"{{condition}}", _condition},
-		{"{{duration}}", _duration}};
+	};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.audio.entry"),
 		     switchLayout, widgetPlaceholders);
 
@@ -214,16 +203,6 @@ void MacroConditionAudioEdit::ConditionChanged(int cond)
 	_entryData->_condition = static_cast<AudioCondition>(cond);
 }
 
-void MacroConditionAudioEdit::DurationChanged(double seconds)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.seconds = seconds;
-}
-
 void MacroConditionAudioEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -234,6 +213,5 @@ void MacroConditionAudioEdit::UpdateEntryData()
 		GetWeakSourceName(_entryData->_audioSource).c_str());
 	_volume->setValue(_entryData->_volume);
 	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
-	_duration->SetDuration(_entryData->_duration);
 	UpdateVolmeterSource();
 }

src/macro-condition-edit.cpp

@@ -16,9 +16,9 @@ bool MacroConditionFactory::Register(const std::string &id,
 std::shared_ptr<MacroCondition>
 MacroConditionFactory::Create(const std::string &id)
 {
-	if (auto it = _methods.find(id); it != _methods.end())
+	if (auto it = _methods.find(id); it != _methods.end()) {
 		return it->second._createFunc();
-
+	}
 	return nullptr;
 }
 
@@ -26,9 +26,9 @@ QWidget *
 MacroConditionFactory::CreateWidget(const std::string &id, QWidget *parent,
 				    std::shared_ptr<MacroCondition> cond)
 {
-	if (auto it = _methods.find(id); it != _methods.end())
+	if (auto it = _methods.find(id); it != _methods.end()) {
 		return it->second._createWidgetFunc(parent, cond);
-
+	}
 	return nullptr;
 }
 
@@ -50,6 +50,14 @@ std::string MacroConditionFactory::GetIdByName(const QString &name)
 	return "";
 }
 
+bool MacroConditionFactory::UsesDurationConstraint(const std::string &id)
+{
+	if (auto it = _methods.find(id); it != _methods.end()) {
+		return it->second._useDurationConstraint;
+	}
+	return false;
+}
+
 static inline void populateLogicSelection(QComboBox *list, bool root = false)
 {
 	if (root) {
@@ -85,18 +93,27 @@ MacroConditionEdit::MacroConditionEdit(
 	_logicSelection = new QComboBox();
 	_conditionSelection = new QComboBox();
 	_section = new Section(300);
+	_dur = new DurationConstraintEdit();
 
 	QWidget::connect(_logicSelection, SIGNAL(currentIndexChanged(int)),
 			 this, SLOT(LogicSelectionChanged(int)));
 	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(ConditionChanged(DurationCondition)),
+			 this,
+			 SLOT(DurationConditionChanged(DurationCondition)));
 
 	populateLogicSelection(_logicSelection, root);
 	populateConditionSelection(_conditionSelection);
 
 	_section->AddHeaderWidget(_logicSelection);
 	_section->AddHeaderWidget(_conditionSelection);
+	_section->AddHeaderWidget(_dur);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
 	mainLayout->addWidget(_section);
@@ -144,6 +161,10 @@ void MacroConditionEdit::UpdateEntryData(const std::string &id, bool collapse)
 						 logic_root_offset);
 	}
 	_section->SetContent(widget, collapse);
+
+	_dur->setVisible(MacroConditionFactory::UsesDurationConstraint(id));
+	auto constraint = (*_entryData)->GetDurationConstraint();
+	_dur->SetValue(constraint);
 }
 
 void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
@@ -154,6 +175,9 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 
 	std::string id = MacroConditionFactory::GetIdByName(text);
 
+	auto temp = DurationConstraint();
+	_dur->SetValue(temp);
+
 	std::lock_guard<std::mutex> lock(switcher->m);
 	auto logic = (*_entryData)->GetLogicType();
 	_entryData->reset();
@@ -162,6 +186,37 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 	auto widget =
 		MacroConditionFactory::CreateWidget(id, window(), *_entryData);
 	_section->SetContent(widget, false);
+	_dur->setVisible(MacroConditionFactory::UsesDurationConstraint(id));
+}
+
+void MacroConditionEdit::DurationChanged(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	(*_entryData)->SetDuration(seconds);
+}
+
+void MacroConditionEdit::DurationConditionChanged(DurationCondition cond)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	(*_entryData)->SetDurationCondition(cond);
+}
+
+void MacroConditionEdit::DurationUnitChanged(DurationUnit unit)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	(*_entryData)->SetDurationUnit(unit);
 }
 
 void AdvSceneSwitcher::on_conditionAdd_clicked()

src/macro-condition-idle.cpp

@@ -8,7 +8,7 @@ const std::string MacroConditionIdle::id = "idle";
 bool MacroConditionIdle::_registered = MacroConditionFactory::Register(
 	MacroConditionIdle::id,
 	{MacroConditionIdle::Create, MacroConditionIdleEdit::Create,
-	 "AdvSceneSwitcher.condition.idle"});
+	 "AdvSceneSwitcher.condition.idle", false});
 
 bool MacroConditionIdle::CheckCondition()
 {

src/macro-condition-interval.cpp

@@ -8,7 +8,7 @@ const std::string MacroConditionInterval::id = "interval";
 bool MacroConditionInterval::_registered = MacroConditionFactory::Register(
 	MacroConditionInterval::id,
 	{MacroConditionInterval::Create, MacroConditionIntervalEdit::Create,
-	 "AdvSceneSwitcher.condition.interval"});
+	 "AdvSceneSwitcher.condition.interval", false});
 
 bool MacroConditionInterval::CheckCondition()
 {

src/macro-condition-plugin-state.cpp

@@ -9,7 +9,7 @@ bool MacroConditionPluginState::_registered = MacroConditionFactory::Register(
 	MacroConditionPluginState::id,
 	{MacroConditionPluginState::Create,
 	 MacroConditionPluginStateEdit::Create,
-	 "AdvSceneSwitcher.condition.pluginState"});
+	 "AdvSceneSwitcher.condition.pluginState", false});
 
 static std::map<PluginStateCondition, std::string> pluginStateConditionTypes = {
 	{PluginStateCondition::SCENESWITCHED,

src/macro-condition-recording.cpp

@@ -32,20 +32,13 @@ bool MacroConditionRecord::CheckCondition()
 	default:
 		break;
 	}
-
-	if (!stateMatch) {
-		_duration.Reset();
-		return false;
-	}
-
-	return _duration.DurationReached();
+	return stateMatch;
 }
 
 bool MacroConditionRecord::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
 	obs_data_set_int(obj, "state", static_cast<int>(_recordState));
-	_duration.Save(obj);
 	return true;
 }
 
@@ -53,7 +46,6 @@ bool MacroConditionRecord::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	_recordState = static_cast<RecordState>(obs_data_get_int(obj, "state"));
-	_duration.Load(obj);
 	return true;
 }
 
@@ -69,14 +61,9 @@ MacroConditionRecordEdit::MacroConditionRecordEdit(
 	: QWidget(parent)
 {
 	_recordState = new QComboBox();
-	_duration = new DurationSelection();
 
 	QWidget::connect(_recordState, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(StateChanged(int)));
-	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
-			 SLOT(DurationChanged(double)));
-	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
-			 SLOT(DurationUnitChanged(DurationUnit)));
 
 	populateStateSelection(_recordState);
 
@@ -84,7 +71,6 @@ MacroConditionRecordEdit::MacroConditionRecordEdit(
 
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{recordState}}", _recordState},
-		{"{{duration}}", _duration},
 	};
 
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.record.entry"),
@@ -106,26 +92,6 @@ void MacroConditionRecordEdit::StateChanged(int value)
 	_entryData->_recordState = static_cast<RecordState>(value);
 }
 
-void MacroConditionRecordEdit::DurationChanged(double seconds)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.seconds = seconds;
-}
-
-void MacroConditionRecordEdit::DurationUnitChanged(DurationUnit unit)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.displayUnit = unit;
-}
-
 void MacroConditionRecordEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -134,5 +100,4 @@ void MacroConditionRecordEdit::UpdateEntryData()
 
 	_recordState->setCurrentIndex(
 		static_cast<int>(_entryData->_recordState));
-	_duration->SetDuration(_entryData->_duration);
 }

src/macro-condition-scene.cpp

@@ -29,11 +29,7 @@ bool MacroConditionScene::CheckCondition()
 		sceneMatch = switcher->previousScene == _scene;
 	}
 
-	if (!sceneMatch) {
-		_duration.Reset();
-		return false;
-	}
-	return _duration.DurationReached();
+	return sceneMatch;
 }
 
 bool MacroConditionScene::Save(obs_data_t *obj)
@@ -41,7 +37,6 @@ bool MacroConditionScene::Save(obs_data_t *obj)
 	MacroCondition::Save(obj);
 	obs_data_set_string(obj, "scene", GetWeakSourceName(_scene).c_str());
 	obs_data_set_int(obj, "type", static_cast<int>(_type));
-	_duration.Save(obj);
 	return true;
 }
 
@@ -50,7 +45,6 @@ bool MacroConditionScene::Load(obs_data_t *obj)
 	MacroCondition::Load(obj);
 	_scene = GetWeakSourceByName(obs_data_get_string(obj, "scene"));
 	_type = static_cast<SceneType>(obs_data_get_int(obj, "type"));
-	_duration.Load(obj);
 	return true;
 }
 
@@ -67,17 +61,12 @@ MacroConditionSceneEdit::MacroConditionSceneEdit(
 {
 	_sceneSelection = new QComboBox();
 	_sceneType = new QComboBox();
-	_duration = new DurationSelection();
 
 	QWidget::connect(_sceneSelection,
 			 SIGNAL(currentTextChanged(const QString &)), this,
 			 SLOT(SceneChanged(const QString &)));
 	QWidget::connect(_sceneType, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(TypeChanged(int)));
-	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
-			 SLOT(DurationChanged(double)));
-	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
-			 SLOT(DurationUnitChanged(DurationUnit)));
 
 	populateSceneSelection(_sceneSelection);
 	populateTypeSelection(_sceneType);
@@ -86,7 +75,6 @@ MacroConditionSceneEdit::MacroConditionSceneEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", _sceneSelection},
 		{"{{sceneType}}", _sceneType},
-		{"{{duration}}", _duration},
 	};
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.scene.entry"),
 		     mainLayout, widgetPlaceholders);
@@ -117,26 +105,6 @@ void MacroConditionSceneEdit::TypeChanged(int value)
 	_entryData->_type = static_cast<SceneType>(value);
 }
 
-void MacroConditionSceneEdit::DurationChanged(double seconds)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.seconds = seconds;
-}
-
-void MacroConditionSceneEdit::DurationUnitChanged(DurationUnit unit)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.displayUnit = unit;
-}
-
 void MacroConditionSceneEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -146,5 +114,4 @@ void MacroConditionSceneEdit::UpdateEntryData()
 	_sceneSelection->setCurrentText(
 		GetWeakSourceName(_entryData->_scene).c_str());
 	_sceneType->setCurrentIndex(static_cast<int>(_entryData->_type));
-	_duration->SetDuration(_entryData->_duration);
 }

src/macro-condition-streaming.cpp

@@ -28,20 +28,13 @@ bool MacroConditionStream::CheckCondition()
 	default:
 		break;
 	}
-
-	if (!stateMatch) {
-		_duration.Reset();
-		return false;
-	}
-
-	return _duration.DurationReached();
+	return stateMatch;
 }
 
 bool MacroConditionStream::Save(obs_data_t *obj)
 {
 	MacroCondition::Save(obj);
 	obs_data_set_int(obj, "state", static_cast<int>(_streamState));
-	_duration.Save(obj);
 	return true;
 }
 
@@ -49,7 +42,6 @@ bool MacroConditionStream::Load(obs_data_t *obj)
 {
 	MacroCondition::Load(obj);
 	_streamState = static_cast<StreamState>(obs_data_get_int(obj, "state"));
-	_duration.Load(obj);
 	return true;
 }
 
@@ -65,14 +57,9 @@ MacroConditionStreamEdit::MacroConditionStreamEdit(
 	: QWidget(parent)
 {
 	_streamState = new QComboBox();
-	_duration = new DurationSelection();
 
 	QWidget::connect(_streamState, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(StateChanged(int)));
-	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
-			 SLOT(DurationChanged(double)));
-	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
-			 SLOT(DurationUnitChanged(DurationUnit)));
 
 	populateStateSelection(_streamState);
 
@@ -80,7 +67,6 @@ MacroConditionStreamEdit::MacroConditionStreamEdit(
 
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{streamState}}", _streamState},
-		{"{{duration}}", _duration},
 	};
 
 	placeWidgets(obs_module_text("AdvSceneSwitcher.condition.stream.entry"),
@@ -102,26 +88,6 @@ void MacroConditionStreamEdit::StateChanged(int value)
 	_entryData->_streamState = static_cast<StreamState>(value);
 }
 
-void MacroConditionStreamEdit::DurationChanged(double seconds)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.seconds = seconds;
-}
-
-void MacroConditionStreamEdit::DurationUnitChanged(DurationUnit unit)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.displayUnit = unit;
-}
-
 void MacroConditionStreamEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -130,5 +96,4 @@ void MacroConditionStreamEdit::UpdateEntryData()
 
 	_streamState->setCurrentIndex(
 		static_cast<int>(_entryData->_streamState));
-	_duration->SetDuration(_entryData->_duration);
 }

src/macro-condition-video.cpp

@@ -39,15 +39,7 @@ bool MacroConditionVideo::CheckCondition()
 
 	if (_screenshotData) {
 		if (_screenshotData->done) {
-			bool imageMatch = Compare();
-
-			if (!imageMatch) {
-				_duration.Reset();
-			}
-
-			if (imageMatch && _duration.DurationReached()) {
-				match = true;
-			}
+			match = Compare();
 
 			if (!requiresFileInput(_condition)) {
 				_matchImage = std::move(_screenshotData->image);
@@ -66,7 +58,6 @@ bool MacroConditionVideo::Save(obs_data_t *obj)
 	obs_data_set_string(obj, "videoSource",
 			    GetWeakSourceName(_videoSource).c_str());
 	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
-	_duration.Save(obj);
 	obs_data_set_string(obj, "filePath", _file.c_str());
 	return true;
 }
@@ -77,7 +68,6 @@ bool MacroConditionVideo::Load(obs_data_t *obj)
 	_videoSource = GetWeakSourceByName(videoSourceName);
 	_condition =
 		static_cast<VideoCondition>(obs_data_get_int(obj, "condition"));
-	_duration.Load(obj);
 	_file = obs_data_get_string(obj, "filePath");
 
 	if (requiresFileInput(_condition)) {
@@ -137,7 +127,6 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 {
 	_videoSelection = new QComboBox();
 	_condition = new QComboBox();
-	_duration = new DurationSelection();
 	_filePath = new QLineEdit();
 	_browseButton =
 		new QPushButton(obs_module_text("AdvSceneSwitcher.browse"));
@@ -151,10 +140,6 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 			 SLOT(SourceChanged(const QString &)));
 	QWidget::connect(_condition, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(ConditionChanged(int)));
-	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
-			 SLOT(DurationChanged(double)));
-	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
-			 SLOT(DurationUnitChanged(DurationUnit)));
 	QWidget::connect(_filePath, SIGNAL(editingFinished()), this,
 			 SLOT(FilePathChanged()));
 	QWidget::connect(_browseButton, SIGNAL(clicked()), this,
@@ -167,7 +152,6 @@ MacroConditionVideoEdit::MacroConditionVideoEdit(
 	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{videoSources}}", _videoSelection},
 		{"{{condition}}", _condition},
-		{"{{duration}}", _duration},
 		{"{{filePath}}", _filePath},
 		{"{{browseButton}}", _browseButton},
 	};
@@ -324,26 +308,6 @@ void MacroConditionVideoEdit::BrowseButtonClicked()
 	SetFilePath(path);
 }
 
-void MacroConditionVideoEdit::DurationChanged(double seconds)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.seconds = seconds;
-}
-
-void MacroConditionVideoEdit::DurationUnitChanged(DurationUnit unit)
-{
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	std::lock_guard<std::mutex> lock(switcher->m);
-	_entryData->_duration.displayUnit = unit;
-}
-
 void MacroConditionVideoEdit::UpdateEntryData()
 {
 	if (!_entryData) {
@@ -353,7 +317,6 @@ void MacroConditionVideoEdit::UpdateEntryData()
 	_videoSelection->setCurrentText(
 		GetWeakSourceName(_entryData->_videoSource).c_str());
 	_condition->setCurrentIndex(static_cast<int>(_entryData->_condition));
-	_duration->SetDuration(_entryData->_duration);
 	_filePath->setText(QString::fromStdString(_entryData->_file));
 
 	if (!requiresFileInput(_entryData->_condition)) {

src/macro.cpp

@@ -33,6 +33,10 @@ bool Macro::CeckMatch()
 	_matched = false;
 	for (auto &c : _conditions) {
 		bool cond = c->CheckCondition();
+		if (!cond) {
+			c->ResetDuration();
+		}
+		cond = cond && c->DurationReached();
 
 		switch (c->GetLogicType()) {
 		case LogicType::NONE:
@@ -350,15 +354,37 @@ bool MacroCondition::Save(obs_data_t *obj)
 {
 	obs_data_set_string(obj, "id", GetId().c_str());
 	obs_data_set_int(obj, "logic", static_cast<int>(_logic));
+	_duration.Save(obj);
 	return true;
 }
 
 bool MacroCondition::Load(obs_data_t *obj)
 {
 	_logic = static_cast<LogicType>(obs_data_get_int(obj, "logic"));
+	_duration.Load(obj);
 	return true;
 }
 
+void MacroCondition::SetDurationConstraint(const DurationConstraint &dur)
+{
+	_duration = dur;
+}
+
+void MacroCondition::SetDurationCondition(DurationCondition cond)
+{
+	_duration.SetCondition(cond);
+}
+
+void MacroCondition::SetDurationUnit(DurationUnit u)
+{
+	_duration.SetUnit(u);
+}
+
+void MacroCondition::SetDuration(double seconds)
+{
+	_duration.SetValue(seconds);
+}
+
 bool MacroAction::Save(obs_data_t *obj)
 {
 	obs_data_set_string(obj, "id", GetId().c_str());