Add macro condition "interval"

CMakeLists.txt

@@ -95,6 +95,7 @@ set(advanced-scene-switcher_HEADERS
 	src/headers/macro-condition-audio.hpp
 	src/headers/macro-condition-file.hpp
 	src/headers/macro-condition-idle.hpp
+	src/headers/macro-condition-interval.hpp
 	src/headers/macro-condition-media.hpp
 	src/headers/macro-condition-plugin-state.hpp
 	src/headers/macro-condition-process.hpp
@@ -154,6 +155,7 @@ set(advanced-scene-switcher_SOURCES
 	src/macro-condition-audio.cpp
 	src/macro-condition-file.cpp
 	src/macro-condition-idle.cpp
+	src/macro-condition-interval.cpp
 	src/macro-condition-media.cpp
 	src/macro-condition-plugin-state.cpp
 	src/macro-condition-process.cpp

data/locale/en-US.ini

@@ -122,6 +122,8 @@ AdvSceneSwitcher.condition.idle.entry="No keyboard or mouse inputs for {{duratio
 AdvSceneSwitcher.condition.pluginState="Plugin state"
 AdvSceneSwitcher.condition.pluginState.state.sceneSwitched="Automated scene change was triggered in this interval"
 AdvSceneSwitcher.condition.pluginState.entry="{{condition}}"
+AdvSceneSwitcher.condition.interval="Interval"
+AdvSceneSwitcher.condition.interval.entry="{{duration}} have passed"
 
 ; Macro Actions
 AdvSceneSwitcher.action.switchScene="Switch scene"

src/headers/macro-condition-interval.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#include "macro.hpp"
+#include <QWidget>
+#include <QComboBox>
+#include "duration-control.hpp"
+
+class MacroConditionInterval : public MacroCondition {
+public:
+	bool CheckCondition();
+	bool Save(obs_data_t *obj);
+	bool Load(obs_data_t *obj);
+	int GetId() { return id; };
+	static std::shared_ptr<MacroCondition> Create()
+	{
+		return std::make_shared<MacroConditionInterval>();
+	}
+
+	Duration _duration;
+
+private:
+	static bool _registered;
+	static const int id;
+};
+
+class MacroConditionIntervalEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionIntervalEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionInterval> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionIntervalEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionInterval>(
+				cond));
+	}
+
+private slots:
+	void DurationChanged(double seconds);
+	void DurationUnitChanged(DurationUnit unit);
+
+protected:
+	DurationSelection *_duration;
+	std::shared_ptr<MacroConditionInterval> _entryData;
+
+private:
+	bool _loading = true;
+};

src/macro-condition-interval.cpp

@@ -0,0 +1,88 @@
+#include "headers/macro-condition-edit.hpp"
+#include "headers/macro-condition-interval.hpp"
+#include "headers/utility.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+
+const int MacroConditionInterval::id = 12;
+
+bool MacroConditionInterval::_registered = MacroConditionFactory::Register(
+	MacroConditionInterval::id,
+	{MacroConditionInterval::Create, MacroConditionIntervalEdit::Create,
+	 "AdvSceneSwitcher.condition.interval"});
+
+bool MacroConditionInterval::CheckCondition()
+{
+	if (_duration.DurationReached()) {
+		_duration.Reset();
+		return true;
+	}
+	return false;
+}
+
+bool MacroConditionInterval::Save(obs_data_t *obj)
+{
+	MacroCondition::Save(obj);
+	_duration.Save(obj);
+	return true;
+}
+
+bool MacroConditionInterval::Load(obs_data_t *obj)
+{
+	MacroCondition::Load(obj);
+	_duration.Load(obj);
+	return true;
+}
+
+MacroConditionIntervalEdit::MacroConditionIntervalEdit(
+	QWidget *parent, std::shared_ptr<MacroConditionInterval> entryData)
+	: QWidget(parent)
+{
+	_duration = new DurationSelection();
+
+	QWidget::connect(_duration, SIGNAL(DurationChanged(double)), this,
+			 SLOT(DurationChanged(double)));
+	QWidget::connect(_duration, SIGNAL(UnitChanged(DurationUnit)), this,
+			 SLOT(DurationUnitChanged(DurationUnit)));
+
+	QHBoxLayout *mainLayout = new QHBoxLayout;
+	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+		{"{{duration}}", _duration},
+	};
+	placeWidgets(
+		obs_module_text("AdvSceneSwitcher.condition.interval.entry"),
+		mainLayout, widgetPlaceholders);
+	setLayout(mainLayout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroConditionIntervalEdit::DurationChanged(double seconds)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.seconds = seconds;
+}
+
+void MacroConditionIntervalEdit::DurationUnitChanged(DurationUnit unit)
+{
+	if (_loading || !_entryData) {
+		return;
+	}
+
+	std::lock_guard<std::mutex> lock(switcher->m);
+	_entryData->_duration.displayUnit = unit;
+}
+
+void MacroConditionIntervalEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_duration->SetDuration(_entryData->_duration);
+}