Restructure files

- Move condition and action related parts into separate files
 - Move duration constraint to macro condition
 - Move duration constraint widget to macro condition edit
 - Adjust includes

CMakeLists.txt

@@ -190,6 +190,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/switch-sequence.hpp
     src/headers/switch-video.hpp
     src/headers/switch-generic.hpp
+    src/headers/macro-action.hpp
     src/headers/macro-action-edit.hpp
     src/headers/macro-action-audio.hpp
     src/headers/macro-action-file.hpp
@@ -218,6 +219,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/macro-action-transition.hpp
     src/headers/macro-action-virtual-cam.hpp
     src/headers/macro-action-wait.hpp
+    src/headers/macro-condition.hpp
     src/headers/macro-condition-edit.hpp
     src/headers/macro-condition-audio.hpp
     src/headers/macro-condition-cursor.hpp
@@ -245,6 +247,7 @@ set(advanced-scene-switcher_HEADERS
     src/headers/macro-condition-virtual-cam.hpp
     src/headers/macro-condition-window.hpp
     src/headers/macro.hpp
+    src/headers/macro-ref.hpp
     src/headers/macro-list-entry-widget.hpp
     src/headers/macro-properties.hpp
     src/headers/macro-segment.hpp
@@ -293,6 +296,7 @@ set(advanced-scene-switcher_SOURCES
     src/switch-audio.cpp
     src/switch-video.cpp
     src/switch-generic.cpp
+    src/macro-action.cpp
     src/macro-action-edit.cpp
     src/macro-action-audio.cpp
     src/macro-action-file.cpp
@@ -321,6 +325,7 @@ set(advanced-scene-switcher_SOURCES
     src/macro-action-transition.cpp
     src/macro-action-virtual-cam.cpp
     src/macro-action-wait.cpp
+    src/macro-condition.cpp
     src/macro-condition-edit.cpp
     src/macro-condition-audio.cpp
     src/macro-condition-cursor.cpp
@@ -348,6 +353,7 @@ set(advanced-scene-switcher_SOURCES
     src/macro-condition-virtual-cam.cpp
     src/macro-condition-window.cpp
     src/macro.cpp
+    src/macro-ref.cpp
     src/macro-list-entry-widget.cpp
     src/macro-properties.cpp
     src/macro-segment.cpp

src/duration-control.cpp

@@ -161,131 +161,3 @@ 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)
-{
-	// 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_set_int(obj, condName,
-				 static_cast<int>(DurationCondition::MORE));
-	}
-
-	_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);
-	_toggle = new QPushButton(parent);
-	_toggle->setMaximumSize(22, 22);
-	_toggle->setIcon(
-		QIcon(QString::fromStdString(getDataFilePath("res/time.svg"))));
-	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);
-	QWidget::connect(_toggle, SIGNAL(clicked()), this,
-			 SLOT(ToggleClicked()));
-
-	QHBoxLayout *layout = new QHBoxLayout;
-	layout->setContentsMargins(0, 0, 0, 0);
-	layout->setSpacing(11);
-	layout->addWidget(_toggle);
-	layout->addWidget(_condition);
-	layout->addWidget(_duration);
-	setLayout(layout);
-	Collapse(true);
-}
-
-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);
-	Collapse(cond == DurationCondition::NONE);
-	emit ConditionChanged(cond);
-}
-
-void DurationConstraintEdit::ToggleClicked()
-{
-	Collapse(false);
-}
-
-void DurationConstraintEdit::Collapse(bool collapse)
-{
-	_toggle->setVisible(collapse);
-	_duration->setVisible(!collapse);
-	_condition->setVisible(!collapse);
-}

src/headers/duration-control.hpp

@@ -57,57 +57,3 @@ 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);
-	void ToggleClicked();
-signals:
-	void DurationChanged(double value);
-	void UnitChanged(DurationUnit u);
-	void ConditionChanged(DurationCondition value);
-
-private:
-	void Collapse(bool collapse);
-
-	DurationSelection *_duration;
-	QComboBox *_condition;
-	QPushButton *_toggle;
-};

src/headers/macro-action-edit.hpp

@@ -1,5 +1,8 @@
 #pragma once
-#include "macro.hpp"
+#include "macro-action.hpp"
+
+#include <QComboBox>
+#include <memory>
 
 struct MacroActionInfo {
 	using TCreateMethod = std::shared_ptr<MacroAction> (*)(Macro *m);

src/headers/macro-action-filter.hpp

@@ -2,7 +2,9 @@
 #include "macro-action-edit.hpp"
 #include "resizing-text-edit.hpp"
 
+#include <QComboBox>
 #include <QSpinBox>
+#include <QPushButton>
 
 enum class FilterAction {
 	ENABLE,

src/headers/macro-action-hotkey.hpp

@@ -2,6 +2,7 @@
 #include "macro-action-edit.hpp"
 #include "hotkey.hpp"
 
+#include <QComboBox>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QHBoxLayout>

src/headers/macro-action-profile.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include "macro-action-edit.hpp"
 
+#include <QComboBox>
+
 class MacroActionProfile : public MacroAction {
 public:
 	MacroActionProfile(Macro *m) : MacroAction(m) {}

src/headers/macro-action-scene-collection.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include "macro-action-edit.hpp"
 
+#include <QComboBox>
+
 class MacroActionSceneCollection : public MacroAction {
 public:
 	MacroActionSceneCollection(Macro *m) : MacroAction(m) {}

src/headers/macro-action-screenshot.hpp

@@ -1,6 +1,8 @@
 #pragma once
 #include "macro-action-edit.hpp"
 
+#include <QComboBox>
+
 class MacroActionScreenshot : public MacroAction {
 public:
 	MacroActionScreenshot(Macro *m) : MacroAction(m) {}

src/headers/macro-action-source.hpp

@@ -5,6 +5,7 @@
 #include <QSpinBox>
 #include <QLabel>
 #include <QPushButton>
+#include <QComboBox>
 
 enum class SourceAction {
 	ENABLE,

src/headers/macro-action.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include "macro-segment.hpp"
+#include "macro-ref.hpp"
+
+class MacroAction : public MacroSegment {
+public:
+	MacroAction(Macro *m) : MacroSegment(m) {}
+	virtual bool PerformAction() = 0;
+	virtual bool Save(obs_data_t *obj) = 0;
+	virtual bool Load(obs_data_t *obj) = 0;
+	virtual void LogAction();
+};
+
+class MacroRefAction : public MacroAction {
+public:
+	MacroRefAction(Macro *m) : MacroAction(m) {}
+	void ResolveMacroRef();
+	MacroRef _macro;
+};
+
+class MultiMacroRefAction : public MacroAction {
+public:
+	MultiMacroRefAction(Macro *m) : MacroAction(m) {}
+	void ResolveMacroRef();
+	std::vector<MacroRef> _macros;
+};

src/headers/macro-condition-edit.hpp

@@ -1,5 +1,7 @@
 #pragma once
-#include "macro.hpp"
+#include "macro-condition.hpp"
+
+#include <memory>
 
 struct MacroConditionInfo {
 	using TCreateMethod = std::shared_ptr<MacroCondition> (*)(Macro *m);
@@ -28,6 +30,30 @@ private:
 	static std::map<std::string, MacroConditionInfo> _methods;
 };
 
+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);
+	void ToggleClicked();
+signals:
+	void DurationChanged(double value);
+	void UnitChanged(DurationUnit u);
+	void ConditionChanged(DurationCondition value);
+
+private:
+	void Collapse(bool collapse);
+
+	DurationSelection *_duration;
+	QComboBox *_condition;
+	QPushButton *_toggle;
+};
+
 class MacroConditionEdit : public MacroSegmentEdit {
 	Q_OBJECT
 

src/headers/macro-condition.hpp

@@ -0,0 +1,88 @@
+#pragma once
+#include "macro-segment.hpp"
+#include "macro-ref.hpp"
+#include "duration-control.hpp"
+
+constexpr auto logic_root_offset = 100;
+
+enum class LogicType {
+	ROOT_NONE = 0,
+	ROOT_NOT,
+	ROOT_LAST,
+	// leave some space for potential expansion
+	NONE = 100,
+	AND,
+	OR,
+	AND_NOT,
+	OR_NOT,
+	LAST,
+};
+
+static inline bool isRootLogicType(LogicType l)
+{
+	return static_cast<int>(l) < logic_root_offset;
+}
+
+struct LogicTypeInfo {
+	std::string _name;
+};
+
+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 MacroCondition : public MacroSegment {
+public:
+	MacroCondition(Macro *m) : MacroSegment(m) {}
+	virtual bool CheckCondition() = 0;
+	virtual bool Save(obs_data_t *obj) = 0;
+	virtual bool Load(obs_data_t *obj) = 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 = LogicType::ROOT_NONE;
+	DurationConstraint _duration;
+};
+
+class MacroRefCondition : public MacroCondition {
+public:
+	MacroRefCondition(Macro *m) : MacroCondition(m) {}
+	void ResolveMacroRef();
+	MacroRef _macro;
+};

src/headers/macro-ref.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <string>
+#include <QString>
+#include <obs-module.h>
+
+class Macro;
+
+class MacroRef {
+public:
+	MacroRef(){};
+	MacroRef(std::string name);
+	void UpdateRef();
+	void UpdateRef(std::string name);
+	void UpdateRef(QString name);
+	void Save(obs_data_t *obj);
+	void Load(obs_data_t *obj);
+	Macro *get();
+	Macro *operator->();
+
+private:
+	std::string _name = "";
+	Macro *_ref = nullptr;
+};

src/headers/macro.hpp

@@ -1,6 +1,7 @@
 #pragma once
-#include "macro-segment.hpp"
-#include "duration-control.hpp"
+#include "macro-action.hpp"
+#include "macro-condition.hpp"
+#include "macro-ref.hpp"
 
 #include <QString>
 #include <string>
@@ -13,62 +14,6 @@
 
 constexpr auto macro_func = 10;
 
-constexpr auto logic_root_offset = 100;
-
-enum class LogicType {
-	ROOT_NONE = 0,
-	ROOT_NOT,
-	ROOT_LAST,
-	// leave some space for potential expansion
-	NONE = 100,
-	AND,
-	OR,
-	AND_NOT,
-	OR_NOT,
-	LAST,
-};
-
-static inline bool isRootLogicType(LogicType l)
-{
-	return static_cast<int>(l) < logic_root_offset;
-}
-
-struct LogicTypeInfo {
-	std::string _name;
-};
-
-class MacroCondition : public MacroSegment {
-public:
-	MacroCondition(Macro *m) : MacroSegment(m) {}
-	virtual bool CheckCondition() = 0;
-	virtual bool Save(obs_data_t *obj) = 0;
-	virtual bool Load(obs_data_t *obj) = 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 = LogicType::ROOT_NONE;
-	DurationConstraint _duration;
-};
-
-class MacroAction : public MacroSegment {
-public:
-	MacroAction(Macro *m) : MacroSegment(m) {}
-	virtual bool PerformAction() = 0;
-	virtual bool Save(obs_data_t *obj) = 0;
-	virtual bool Load(obs_data_t *obj) = 0;
-	virtual void LogAction();
-};
-
 class Macro {
 public:
 	Macro(const std::string &name = "");
@@ -155,41 +100,3 @@ private:
 
 Macro *GetMacroByName(const char *name);
 Macro *GetMacroByQString(const QString &name);
-
-class MacroRef {
-public:
-	MacroRef(){};
-	MacroRef(std::string name);
-	void UpdateRef();
-	void UpdateRef(std::string name);
-	void UpdateRef(QString name);
-	void Save(obs_data_t *obj);
-	void Load(obs_data_t *obj);
-	Macro *get();
-	Macro *operator->();
-
-private:
-	std::string _name = "";
-	Macro *_ref = nullptr;
-};
-
-class MacroRefCondition : public MacroCondition {
-public:
-	MacroRefCondition(Macro *m) : MacroCondition(m) {}
-	void ResolveMacroRef();
-	MacroRef _macro;
-};
-
-class MacroRefAction : public MacroAction {
-public:
-	MacroRefAction(Macro *m) : MacroAction(m) {}
-	void ResolveMacroRef();
-	MacroRef _macro;
-};
-
-class MultiMacroRefAction : public MacroAction {
-public:
-	MultiMacroRefAction(Macro *m) : MacroAction(m) {}
-	void ResolveMacroRef();
-	std::vector<MacroRef> _macros;
-};

src/macro-action.cpp

@@ -0,0 +1,32 @@
+#include "headers/macro-action.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+
+bool MacroAction::Save(obs_data_t *obj)
+{
+	MacroSegment::Save(obj);
+	obs_data_set_string(obj, "id", GetId().c_str());
+	return true;
+}
+
+bool MacroAction::Load(obs_data_t *obj)
+{
+	MacroSegment::Load(obj);
+	return true;
+}
+
+void MacroAction::LogAction()
+{
+	vblog(LOG_INFO, "performed action %s", GetId().c_str());
+}
+
+void MacroRefAction::ResolveMacroRef()
+{
+	_macro.UpdateRef();
+}
+
+void MultiMacroRefAction::ResolveMacroRef()
+{
+	for (auto &m : _macros) {
+		m.UpdateRef();
+	}
+}

src/macro-condition-edit.cpp

@@ -97,6 +97,82 @@ static inline void populateConditionSelection(QComboBox *list)
 	list->model()->sort(0);
 }
 
+static void populateDurationConstraintTypes(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);
+	_toggle = new QPushButton(parent);
+	_toggle->setMaximumSize(22, 22);
+	_toggle->setIcon(
+		QIcon(QString::fromStdString(getDataFilePath("res/time.svg"))));
+	populateDurationConstraintTypes(_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);
+	QWidget::connect(_toggle, SIGNAL(clicked()), this,
+			 SLOT(ToggleClicked()));
+
+	QHBoxLayout *layout = new QHBoxLayout;
+	layout->setContentsMargins(0, 0, 0, 0);
+	layout->setSpacing(11);
+	layout->addWidget(_toggle);
+	layout->addWidget(_condition);
+	layout->addWidget(_duration);
+	setLayout(layout);
+	Collapse(true);
+}
+
+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);
+	Collapse(cond == DurationCondition::NONE);
+	emit ConditionChanged(cond);
+}
+
+void DurationConstraintEdit::ToggleClicked()
+{
+	Collapse(false);
+}
+
+void DurationConstraintEdit::Collapse(bool collapse)
+{
+	_toggle->setVisible(collapse);
+	_duration->setVisible(!collapse);
+	_condition->setVisible(!collapse);
+}
+
 MacroConditionEdit::MacroConditionEdit(
 	QWidget *parent, std::shared_ptr<MacroCondition> *entryData,
 	const std::string &id, bool root)

src/macro-condition.cpp

@@ -0,0 +1,106 @@
+#include "headers/macro-condition.hpp"
+#include "headers/advanced-scene-switcher.hpp"
+
+const std::map<LogicType, LogicTypeInfo> MacroCondition::logicTypes = {
+	{LogicType::NONE, {"AdvSceneSwitcher.logic.none"}},
+	{LogicType::AND, {"AdvSceneSwitcher.logic.and"}},
+	{LogicType::OR, {"AdvSceneSwitcher.logic.or"}},
+	{LogicType::AND_NOT, {"AdvSceneSwitcher.logic.andNot"}},
+	{LogicType::OR_NOT, {"AdvSceneSwitcher.logic.orNot"}},
+	{LogicType::ROOT_NONE, {"AdvSceneSwitcher.logic.rootNone"}},
+	{LogicType::ROOT_NOT, {"AdvSceneSwitcher.logic.not"}},
+};
+
+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)
+{
+	// 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_set_int(obj, condName,
+				 static_cast<int>(DurationCondition::MORE));
+	}
+
+	_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();
+}
+
+bool MacroCondition::Save(obs_data_t *obj)
+{
+	MacroSegment::Save(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)
+{
+	MacroSegment::Load(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);
+}
+
+void MacroRefCondition::ResolveMacroRef()
+{
+	_macro.UpdateRef();
+}

src/macro-ref.cpp

@@ -0,0 +1,42 @@
+#include "headers/macro-ref.hpp"
+#include "headers/macro.hpp"
+
+MacroRef::MacroRef(std::string name) : _name(name)
+{
+	UpdateRef();
+}
+void MacroRef::UpdateRef()
+{
+	_ref = GetMacroByName(_name.c_str());
+}
+void MacroRef::UpdateRef(std::string newName)
+{
+	_name = newName;
+	UpdateRef();
+}
+void MacroRef::UpdateRef(QString newName)
+{
+	_name = newName.toStdString();
+	UpdateRef();
+}
+void MacroRef::Save(obs_data_t *obj)
+{
+	if (_ref) {
+		obs_data_set_string(obj, "macro", _ref->Name().c_str());
+	}
+}
+void MacroRef::Load(obs_data_t *obj)
+{
+	_name = obs_data_get_string(obj, "macro");
+	UpdateRef();
+}
+
+Macro *MacroRef::get()
+{
+	return _ref;
+}
+
+Macro *MacroRef::operator->()
+{
+	return _ref;
+}

src/macro.cpp

@@ -11,16 +11,6 @@
 
 constexpr int perfLogThreshold = 300;
 
-const std::map<LogicType, LogicTypeInfo> MacroCondition::logicTypes = {
-	{LogicType::NONE, {"AdvSceneSwitcher.logic.none"}},
-	{LogicType::AND, {"AdvSceneSwitcher.logic.and"}},
-	{LogicType::OR, {"AdvSceneSwitcher.logic.or"}},
-	{LogicType::AND_NOT, {"AdvSceneSwitcher.logic.andNot"}},
-	{LogicType::OR_NOT, {"AdvSceneSwitcher.logic.orNot"}},
-	{LogicType::ROOT_NONE, {"AdvSceneSwitcher.logic.rootNone"}},
-	{LogicType::ROOT_NOT, {"AdvSceneSwitcher.logic.not"}},
-};
-
 Macro::Macro(const std::string &name)
 {
 	SetName(name);
@@ -579,61 +569,6 @@ void Macro::SetHotkeysDesc()
 				   _name, _togglePauseHotkey);
 }
 
-bool MacroCondition::Save(obs_data_t *obj)
-{
-	MacroSegment::Save(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)
-{
-	MacroSegment::Load(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)
-{
-	MacroSegment::Save(obj);
-	obs_data_set_string(obj, "id", GetId().c_str());
-	return true;
-}
-
-bool MacroAction::Load(obs_data_t *obj)
-{
-	MacroSegment::Load(obj);
-	return true;
-}
-
-void MacroAction::LogAction()
-{
-	vblog(LOG_INFO, "performed action %s", GetId().c_str());
-}
-
 void SwitcherData::saveMacros(obs_data_t *obj)
 {
 	switcher->macroProperties.Save(obj);
@@ -720,60 +655,3 @@ Macro *GetMacroByQString(const QString &name)
 {
 	return GetMacroByName(name.toUtf8().constData());
 }
-
-MacroRef::MacroRef(std::string name) : _name(name)
-{
-	UpdateRef();
-}
-void MacroRef::UpdateRef()
-{
-	_ref = GetMacroByName(_name.c_str());
-}
-void MacroRef::UpdateRef(std::string newName)
-{
-	_name = newName;
-	UpdateRef();
-}
-void MacroRef::UpdateRef(QString newName)
-{
-	_name = newName.toStdString();
-	UpdateRef();
-}
-void MacroRef::Save(obs_data_t *obj)
-{
-	if (_ref) {
-		obs_data_set_string(obj, "macro", _ref->Name().c_str());
-	}
-}
-void MacroRef::Load(obs_data_t *obj)
-{
-	_name = obs_data_get_string(obj, "macro");
-	UpdateRef();
-}
-
-Macro *MacroRef::get()
-{
-	return _ref;
-}
-
-Macro *MacroRef::operator->()
-{
-	return _ref;
-}
-
-void MacroRefCondition::ResolveMacroRef()
-{
-	_macro.UpdateRef();
-}
-
-void MacroRefAction::ResolveMacroRef()
-{
-	_macro.UpdateRef();
-}
-
-void MultiMacroRefAction::ResolveMacroRef()
-{
-	for (auto &m : _macros) {
-		m.UpdateRef();
-	}
-}