Rework time restriction to support "within" duration modifier

Also renamed duration constraint to duration modifier

src/headers/duration-control.hpp

@@ -21,6 +21,7 @@ public:
 		  const char *unitName = "displayUnit");
 
 	bool DurationReached();
+	bool IsReset();
 	double TimeRemaining();
 	void SetTimeRemaining(double);
 	void Reset();

src/headers/macro-condition-edit.hpp

@@ -10,7 +10,7 @@ struct MacroConditionInfo {
 	TCreateMethod _createFunc = nullptr;
 	TCreateWidgetMethod _createWidgetFunc = nullptr;
 	std::string _name;
-	bool _useDurationConstraint = true;
+	bool _useDurationModifier = true;
 };
 
 class MacroConditionFactory {
@@ -24,27 +24,27 @@ 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);
+	static bool UsesDurationModifier(const std::string &id);
 
 private:
 	static std::map<std::string, MacroConditionInfo> _methods;
 };
 
-class DurationConstraintEdit : public QWidget {
+class DurationModifierEdit : public QWidget {
 	Q_OBJECT
 public:
-	DurationConstraintEdit(QWidget *parent = nullptr);
-	void SetValue(DurationConstraint &value);
+	DurationModifierEdit(QWidget *parent = nullptr);
+	void SetValue(DurationModifier &value);
 	void SetUnit(DurationUnit u);
 	void SetDuration(const Duration &d);
 
 private slots:
-	void _ConditionChanged(int value);
+	void _ModifierChanged(int value);
 	void ToggleClicked();
 signals:
 	void DurationChanged(double value);
 	void UnitChanged(DurationUnit u);
-	void ConditionChanged(DurationCondition value);
+	void ModifierChanged(DurationModifier::Type value);
 
 private:
 	void Collapse(bool collapse);
@@ -70,7 +70,7 @@ private slots:
 	void LogicSelectionChanged(int idx);
 	void ConditionSelectionChanged(const QString &text);
 	void DurationChanged(double seconds);
-	void DurationConditionChanged(DurationCondition cond);
+	void DurationModifierChanged(DurationModifier::Type m);
 	void DurationUnitChanged(DurationUnit unit);
 
 private:
@@ -79,7 +79,7 @@ private:
 
 	QComboBox *_logicSelection;
 	QComboBox *_conditionSelection;
-	DurationConstraintEdit *_dur;
+	DurationModifierEdit *_dur;
 
 	std::shared_ptr<MacroCondition> *_entryData;
 	bool _isRoot = true;

src/headers/macro-condition.hpp

@@ -27,32 +27,34 @@ struct LogicTypeInfo {
 	std::string _name;
 };
 
-enum class DurationCondition {
-	NONE,
-	MORE,
-	EQUAL,
-	LESS,
-};
-
-class DurationConstraint {
+class DurationModifier {
 public:
+	enum class Type {
+		NONE,
+		MORE,
+		EQUAL,
+		LESS,
+		WITHIN, // Condition will remain true for a set a amount of time
+			// regardless of current state
+	};
+
 	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 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; }
-	DurationCondition GetCondition() { return _type; }
+	Type GetType() { return _type; }
 	Duration GetDuration() { return _dur; }
 	bool DurationReached();
 	void Reset();
 
 private:
-	DurationCondition _type = DurationCondition::NONE;
+	Type _type = Type::NONE;
 	Duration _dur;
 	bool _timeReached = false;
 };
@@ -66,18 +68,16 @@ public:
 	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 ResetDuration();
+	void CheckDurationModifier(bool &val);
+	DurationModifier GetDurationModifier() { return _duration; }
+	void SetDurationModifier(DurationModifier::Type m);
 	void SetDurationUnit(DurationUnit u);
 	void SetDuration(double seconds);
 
 private:
 	LogicType _logic = LogicType::ROOT_NONE;
-	DurationConstraint _duration;
+	DurationModifier _duration;
 };
 
 class MacroRefCondition : public MacroCondition {