Add support to check values of individual transform settings

data/locale/de-DE.ini

@@ -321,11 +321,8 @@ AdvSceneSwitcher.condition.date.entry.nextMatchDate="Nächster Treffer bei: %1"
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}} Bei Wiederholung ausgewähltes Datum auf Wiederholungsdatum aktualisieren"
 AdvSceneSwitcher.condition.sceneTransform="Szenenelement transformieren"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Transformation erhalten"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="Auf{{scenes}}{{sources}}{{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="entspricht Transformation"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.changed="hat sich geändert"
-AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}"
 AdvSceneSwitcher.condition.transition="Übergang"
 AdvSceneSwitcher.condition.transition.type.current="Aktueller Übergangstyp ist"
 AdvSceneSwitcher.condition.transition.type.duration="Aktuelle Übergangsdauer beträgt"

data/locale/en-US.ini

@@ -531,11 +531,17 @@ AdvSceneSwitcher.condition.date.entry.nextMatchDate="Next match at: %1"
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}}On repeat update selected date to repeat date"
 AdvSceneSwitcher.condition.sceneTransform="Scene item transform"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Get transform"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="On{{scenes}}{{sources}}{{types}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="matches transform"
-AdvSceneSwitcher.condition.sceneTransform.entry.type.changed="has changed"
-AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}}{{getSettings}}"
+AdvSceneSwitcher.condition.sceneTransform.getCurrentValue="Get current value"
+AdvSceneSwitcher.condition.sceneTransform.settingsType.all="All"
+AdvSceneSwitcher.condition.sceneTransform.settingsType.single="Single"
+AdvSceneSwitcher.condition.sceneTransform.condition.match="matches"
+AdvSceneSwitcher.condition.sceneTransform.condition.changed="has changed"
+AdvSceneSwitcher.condition.sceneTransform.compare.less="less"
+AdvSceneSwitcher.condition.sceneTransform.compare.equal="equal"
+AdvSceneSwitcher.condition.sceneTransform.compare.more="larger than"
+AdvSceneSwitcher.condition.sceneTransform.entry="On{{scenes}}{{settingsType}}transform setting of{{sources}}{{conditions}}"
+AdvSceneSwitcher.condition.sceneTransform.entry.singleSettingCompare="{{setting}}{{compare}}{{singleSettingValue}}"
+AdvSceneSwitcher.condition.sceneTransform.entry.options="{{regex}}{{getSettings}}{{getCurrentValue}}"
 AdvSceneSwitcher.condition.transition="Transition"
 AdvSceneSwitcher.condition.transition.type.current="Current transition type is"
 AdvSceneSwitcher.condition.transition.type.duration="Current transition duration is"
@@ -1796,6 +1802,9 @@ AdvSceneSwitcher.tempVar.usb.vendorName="Vendor Name"
 AdvSceneSwitcher.tempVar.usb.productName="Product Name"
 AdvSceneSwitcher.tempVar.usb.serialNumber="Serial Number"
 
+AdvSceneSwitcher.tempVar.transform.setting="Setting value"
+AdvSceneSwitcher.tempVar.transform.settings="Settings string"
+
 AdvSceneSwitcher.selectScene="--select scene--"
 AdvSceneSwitcher.selectPreviousScene="Previous Scene"
 AdvSceneSwitcher.selectCurrentScene="Current Scene"

data/locale/es-ES.ini

@@ -269,10 +269,7 @@ AdvSceneSwitcher.condition.date.entry.nextMatchDate="Próxima coincidencia en: %
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}} Al repetir actualizar la fecha seleccionada para repetir la fecha"
 AdvSceneSwitcher.condition.sceneTransform="Transformar elemento de escena"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Obtener transformación"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="En{{scenes}}{{sources}}{{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="coincide con la transformación"
-AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}"
 AdvSceneSwitcher.condition.transition="Transición"
 AdvSceneSwitcher.condition.transition.type.current="El tipo de transición actual es"
 AdvSceneSwitcher.condition.transition.type.duration="La duración de la transición actual es"

data/locale/fr-FR.ini

@@ -382,7 +382,6 @@ AdvSceneSwitcher.condition.date.entry.nextMatchDate="Prochaine correspondance à
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}}À la répétition, mettre à jour la date sélectionnée pour la date de répétition"
 AdvSceneSwitcher.condition.sceneTransform="Transformation de l'élément de la scène"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Obtenir la transformation"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="Sur{{scenes}}{{sources}}{{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="correspond à la transformation"
 AdvSceneSwitcher.condition.transition="Transition"
 AdvSceneSwitcher.condition.transition.type.current="Le type de transition actuel est"

data/locale/ja-JP.ini

@@ -531,11 +531,8 @@ AdvSceneSwitcher.condition.date.entry.pattern="現在の日付「{{currentDate}}
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}}繰り返しの場合、選択した日付を繰り返しの日付に更新します"
 ; AdvSceneSwitcher.condition.sceneTransform="Scene item transform"
 ; AdvSceneSwitcher.condition.sceneTransform.getTransform="Get transform"
-; AdvSceneSwitcher.condition.sceneTransform.entry.line1="On{{scenes}}{{sources}}{{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="マッチトランスフォーム"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.changed="変わりました"
-; AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-; AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}}{{getSettings}}"
 ; AdvSceneSwitcher.condition.transition="Transition"
 ; AdvSceneSwitcher.condition.transition.type.current="Current transition type is"
 AdvSceneSwitcher.condition.transition.type.duration="Current transition duration is"

data/locale/tr-TR.ini

@@ -226,10 +226,7 @@ AdvSceneSwitcher.condition.date.state.before="Önce"
 AdvSceneSwitcher.condition.date.state.between="Arasında"
 AdvSceneSwitcher.condition.sceneTransform="Sahne öğesi dönüşümü"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="Dönüşümü al"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="Açık{{scenes}}{{sources}}{{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="dönüşümle eşleşir"
-AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}"
 AdvSceneSwitcher.condition.transition="Geçiş"
 AdvSceneSwitcher.condition.transition.type.current="Geçerli geçiş türü"
 AdvSceneSwitcher.condition.transition.type.duration="Mevcut geçiş süresi"

data/locale/zh-CN.ini

@@ -365,10 +365,7 @@ AdvSceneSwitcher.condition.date.entry.nextMatchDate="下一次匹配 在: %1"
 AdvSceneSwitcher.condition.date.entry.updateOnRepeat="{{updateOnRepeat}} 重复时,将选定的日期更新为重复日期"
 AdvSceneSwitcher.condition.sceneTransform="场景项目被改变"
 AdvSceneSwitcher.condition.sceneTransform.getTransform="内容或者设置被改变了"
-AdvSceneSwitcher.condition.sceneTransform.entry.line1="在 {{scenes}} {{sources}} {{types}}"
 AdvSceneSwitcher.condition.sceneTransform.entry.type.matches="匹配变换"
-AdvSceneSwitcher.condition.sceneTransform.entry.line2="{{settings}}"
-AdvSceneSwitcher.condition.sceneTransform.entry.line3="{{regex}} {{getSettings}}"
 AdvSceneSwitcher.condition.transition="转场"
 AdvSceneSwitcher.condition.transition.type.current="当前转场特效类型为"
 AdvSceneSwitcher.condition.transition.type.duration="当前转场特效持续时间为"

plugins/base/macro-condition-scene-transform.cpp

@@ -1,6 +1,7 @@
 #include "macro-condition-scene-transform.hpp"
 #include "layout-helpers.hpp"
 #include "json-helpers.hpp"
+#include "math-helpers.hpp"
 #include "text-helpers.hpp"
 #include "scene-item-transform-helpers.hpp"
 
@@ -15,12 +16,28 @@ bool MacroConditionSceneTransform::_registered =
 		 MacroConditionSceneTransformEdit::Create,
 		 "AdvSceneSwitcher.condition.sceneTransform"});
 
-const static std::map<MacroConditionSceneTransform::CondType, std::string>
+static const std::map<MacroConditionSceneTransform::SettingsType, std::string>
+	settingsTypes = {
+		{MacroConditionSceneTransform::SettingsType::ALL,
+		 "AdvSceneSwitcher.condition.sceneTransform.settingsType.all"},
+		{MacroConditionSceneTransform::SettingsType::SINGLE,
+		 "AdvSceneSwitcher.condition.sceneTransform.settingsType.single"},
+};
+static const std::map<MacroConditionSceneTransform::Compare, std::string>
+	compareTypes = {
+		{MacroConditionSceneTransform::Compare::LESS,
+		 "AdvSceneSwitcher.condition.sceneTransform.compare.less"},
+		{MacroConditionSceneTransform::Compare::EQUAL,
+		 "AdvSceneSwitcher.condition.sceneTransform.compare.equal"},
+		{MacroConditionSceneTransform::Compare::MORE,
+		 "AdvSceneSwitcher.condition.sceneTransform.compare.more"},
+};
+static const std::map<MacroConditionSceneTransform::Condition, std::string>
 	conditionTypes = {
-		{MacroConditionSceneTransform::CondType::MATCHES,
-		 "AdvSceneSwitcher.condition.sceneTransform.entry.type.matches"},
-		{MacroConditionSceneTransform::CondType::CHANGED,
-		 "AdvSceneSwitcher.condition.sceneTransform.entry.type.changed"},
+		{MacroConditionSceneTransform::Condition::MATCHES,
+		 "AdvSceneSwitcher.condition.sceneTransform.condition.match"},
+		{MacroConditionSceneTransform::Condition::CHANGED,
+		 "AdvSceneSwitcher.condition.sceneTransform.condition.changed"},
 };
 
 static bool doesTransformOfAnySceneItemMatch(
@@ -64,21 +81,17 @@ didTransformOfAnySceneItemChange(const std::vector<OBSSceneItem> &items,
 	return ret;
 }
 
-bool MacroConditionSceneTransform::CheckCondition()
+bool MacroConditionSceneTransform::CheckAllSettings(
+	const std::vector<OBSSceneItem> &items)
 {
-	auto items = _source.GetSceneItems(_scene);
-	if (items.empty()) {
-		return false;
-	}
-
 	std::string newVariable = "";
 	bool ret = false;
-	switch (_type) {
-	case CondType::MATCHES:
-		ret = doesTransformOfAnySceneItemMatch(items, _settings, _regex,
-						       newVariable);
+	switch (_condition) {
+	case Condition::MATCHES:
+		ret = doesTransformOfAnySceneItemMatch(items, _transformString,
+						       _regex, newVariable);
 		break;
-	case CondType::CHANGED:
+	case Condition::CHANGED:
 		ret = didTransformOfAnySceneItemChange(
 			items, _previousTransform, newVariable);
 		break;
@@ -88,17 +101,143 @@ bool MacroConditionSceneTransform::CheckCondition()
 	}
 
 	SetVariableValue(newVariable);
+	SetTempVarValue("settings", newVariable);
 	return ret;
 }
 
+bool MacroConditionSceneTransform::AnySceneItemTransformSettingChanged(
+	const std::vector<OBSSceneItem> &items)
+{
+	bool ret = false;
+	if (_previousSettingValues.size() < items.size()) {
+		_previousSettingValues.resize(items.size());
+		return true;
+	}
+
+	std::vector<std::string> varValues;
+
+	for (size_t i = 0; i < items.size(); i++) {
+		const auto &item = items[i];
+		auto &previousValue = _previousSettingValues[i];
+
+		const auto currentValue =
+			GetTransformSettingValue(item, _setting);
+		if (!currentValue) {
+			continue;
+		}
+		varValues.emplace_back(*currentValue);
+
+		if (*currentValue == previousValue) {
+			continue;
+		}
+		previousValue = *currentValue;
+		ret = true;
+	}
+
+	SetTempVarHelper(varValues);
+	return ret;
+}
+
+static bool compareValue(MacroConditionSceneTransform::Compare compareMethod,
+			 double value1, double value2)
+{
+	switch (compareMethod) {
+	case MacroConditionSceneTransform::Compare::LESS:
+		return value1 < value2;
+	case MacroConditionSceneTransform::Compare::EQUAL:
+		return DoubleEquals(value1, value2, 0.00001);
+	case MacroConditionSceneTransform::Compare::MORE:
+		return value1 > value2;
+	default:
+		break;
+	}
+	return false;
+}
+
+bool MacroConditionSceneTransform::AnySceneItemTransformSettingMatches(
+	const std::vector<OBSSceneItem> &items)
+{
+	bool ret = false;
+	std::vector<std::string> varValues;
+
+	for (const auto &item : items) {
+		const auto currentValue =
+			GetTransformSettingValue(item, _setting);
+		if (!currentValue) {
+			continue;
+		}
+		try {
+			if (compareValue(_compare, std::stod(*currentValue),
+					 std::stod(_singleSetting))) {
+				ret = true;
+			}
+		} catch (std::invalid_argument &) {
+		} catch (std::out_of_range &) {
+		}
+
+		varValues.emplace_back(*currentValue);
+	}
+
+	SetTempVarHelper(varValues);
+	return ret;
+}
+
+void MacroConditionSceneTransform::SetTempVarHelper(
+	const std::vector<std::string> &values)
+{
+	std::string varValue;
+	bool addSeperator = false;
+	for (const auto &value : values) {
+		if (addSeperator) {
+			varValue += ";";
+		}
+		varValue += value;
+		addSeperator = true;
+	}
+	SetTempVarValue("setting", varValue);
+}
+
+bool MacroConditionSceneTransform::CheckSingleSetting(
+	const std::vector<OBSSceneItem> &items)
+{
+	if (_condition == Condition::CHANGED) {
+		return AnySceneItemTransformSettingChanged(items);
+	}
+	return AnySceneItemTransformSettingMatches(items);
+}
+
+bool MacroConditionSceneTransform::CheckCondition()
+{
+	auto items = _source.GetSceneItems(_scene);
+	if (items.empty()) {
+		return false;
+	}
+
+	switch (_settingsType) {
+	case SettingsType::ALL:
+		return CheckAllSettings(items);
+	case SettingsType::SINGLE:
+		return CheckSingleSetting(items);
+	default:
+		break;
+	}
+
+	return false;
+}
+
 bool MacroConditionSceneTransform::Save(obs_data_t *obj) const
 {
 	MacroCondition::Save(obj);
 	_scene.Save(obj);
 	_source.Save(obj);
-	_settings.Save(obj, "settings");
+	_transformString.Save(obj, "transformString");
+	_singleSetting.Save(obj, "singleSetting");
 	_regex.Save(obj);
-	obs_data_set_int(obj, "type", static_cast<int>(_type));
+	_setting.Save(obj);
+	obs_data_set_int(obj, "settingsType", static_cast<int>(_settingsType));
+	obs_data_set_int(obj, "compare", static_cast<int>(_compare));
+	obs_data_set_int(obj, "condition", static_cast<int>(_condition));
+	obs_data_set_int(obj, "version", 1);
 	return true;
 }
 
@@ -114,14 +253,32 @@ bool MacroConditionSceneTransform::Load(obs_data_t *obj)
 	MacroCondition::Load(obj);
 	_scene.Load(obj);
 	_source.Load(obj);
-	_settings.Load(obj, "settings");
+	_transformString.Load(obj, "transformString");
+	_singleSetting.Load(obj, "singleSetting");
 	_regex.Load(obj);
-	_type = static_cast<CondType>(obs_data_get_int(obj, "type"));
+	_setting.Load(obj);
+	SetSettingsType(static_cast<SettingsType>(
+		obs_data_get_int(obj, "settingsType")));
+	_compare = static_cast<Compare>(obs_data_get_int(obj, "compare"));
+	SetCondition(
+		static_cast<Condition>(obs_data_get_int(obj, "condition")));
+
 	// TOOD: remove in future version
 	if (obs_data_has_user_value(obj, "regex")) {
 		_regex.CreateBackwardsCompatibleRegex(
 			obs_data_get_bool(obj, "regex"));
 	}
+
+	if (!obs_data_has_user_value(obj, "version")) {
+		SetCondition(
+			static_cast<Condition>(obs_data_get_int(obj, "type")));
+		_transformString.Load(obj, "settings");
+		SetSettingsType(SettingsType::ALL);
+		_compare = Compare::EQUAL;
+	}
+
+	SetupTempVars();
+
 	return true;
 }
 
@@ -134,10 +291,41 @@ std::string MacroConditionSceneTransform::GetShortDesc() const
 	return _scene.ToString() + " - " + _source.ToString();
 }
 
-static inline void populateTypesSelection(QComboBox *list)
+void MacroConditionSceneTransform::SetSettingsType(SettingsType type)
 {
-	for (const auto &entry : conditionTypes) {
-		list->addItem(obs_module_text(entry.second.c_str()));
+	_settingsType = type;
+	SetupTempVars();
+}
+
+void MacroConditionSceneTransform::SetCondition(Condition condition)
+{
+	_condition = condition;
+	_previousTransform.clear();
+	_previousSettingValues.clear();
+}
+
+void MacroConditionSceneTransform::SetupTempVars()
+{
+	MacroCondition::SetupTempVars();
+	if (_settingsType == SettingsType::ALL) {
+		AddTempvar(
+			"settings",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.transform.settings"));
+	} else {
+		AddTempvar(
+			"setting",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.transform.setting"));
+	}
+}
+
+template<class T>
+static inline void populateSelection(QComboBox *list,
+				     const std::map<T, std::string> &map)
+{
+	for (const auto &[_, name] : map) {
+		list->addItem(obs_module_text(name.c_str()));
 	}
 }
 
@@ -148,13 +336,22 @@ MacroConditionSceneTransformEdit::MacroConditionSceneTransformEdit(
 	  _scenes(new SceneSelectionWidget(window(), true, false, false, true)),
 	  _sources(new SceneItemSelectionWidget(
 		  parent, true, SceneItemSelectionWidget::Placeholder::ANY)),
-	  _types(new QComboBox()),
+	  _settingsType(new QComboBox()),
+	  _compare(new QComboBox()),
+	  _conditions(new QComboBox()),
 	  _getSettings(new QPushButton(obs_module_text(
 		  "AdvSceneSwitcher.condition.sceneTransform.getTransform"))),
-	  _settings(new VariableTextEdit(this)),
-	  _regex(new RegexConfigWidget(parent))
+	  _getCurrentValue(new QPushButton(obs_module_text(
+		  "AdvSceneSwitcher.condition.sceneTransform.getCurrentValue"))),
+	  _transformString(new VariableTextEdit(this)),
+	  _singleSettingValue(new VariableLineEdit(this)),
+	  _regex(new RegexConfigWidget(parent)),
+	  _settingSelection(new TransformSettingSelection(this)),
+	  _compareLayout(new QHBoxLayout())
 {
-	populateTypesSelection(_types);
+	populateSelection(_settingsType, settingsTypes);
+	populateSelection(_compare, compareTypes);
+	populateSelection(_conditions, conditionTypes);
 
 	QWidget::connect(_scenes, SIGNAL(SceneChanged(const SceneSelection &)),
 			 this, SLOT(SceneChanged(const SceneSelection &)));
@@ -163,45 +360,62 @@ MacroConditionSceneTransformEdit::MacroConditionSceneTransformEdit(
 	QWidget::connect(_sources,
 			 SIGNAL(SceneItemChanged(const SceneItemSelection &)),
 			 this, SLOT(SourceChanged(const SceneItemSelection &)));
-	QWidget::connect(_types, SIGNAL(currentIndexChanged(int)), this,
-			 SLOT(TypeChanged(int)));
+	QWidget::connect(_settingsType, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(SettingsTypeChanged(int)));
+	QWidget::connect(_compare, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(CompareChanged(int)));
+	QWidget::connect(_conditions, SIGNAL(currentIndexChanged(int)), this,
+			 SLOT(ConditionChanged(int)));
+	QWidget::connect(
+		_settingSelection,
+		SIGNAL(SelectionChanged(const TransformSetting &)), this,
+		SLOT(SettingSelectionChanged(const TransformSetting &)));
 	QWidget::connect(_getSettings, SIGNAL(clicked()), this,
 			 SLOT(GetSettingsClicked()));
-	QWidget::connect(_settings, SIGNAL(textChanged()), this,
-			 SLOT(SettingsChanged()));
+	QWidget::connect(_getCurrentValue, SIGNAL(clicked()), this,
+			 SLOT(GetCurrentValueClicked()));
+	QWidget::connect(_transformString, SIGNAL(textChanged()), this,
+			 SLOT(TransformChanged()));
+	QWidget::connect(_singleSettingValue, SIGNAL(editingFinished()), this,
+			 SLOT(SettingValueChanged()));
 	QWidget::connect(_regex,
 			 SIGNAL(RegexConfigChanged(const RegexConfig &)), this,
 			 SLOT(RegexChanged(const RegexConfig &)));
 
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
+	const std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
 		{"{{scenes}}", _scenes},
 		{"{{sources}}", _sources},
-		{"{{types}}", _types},
-		{"{{settings}}", _settings},
+		{"{{compare}}", _compare},
+		{"{{setting}}", _settingSelection},
+		{"{{settingsType}}", _settingsType},
+		{"{{conditions}}", _conditions},
+		{"{{transformString}}", _transformString},
+		{"{{singleSettingValue}}", _singleSettingValue},
+		{"{{settings}}", _singleSettingValue},
 		{"{{getSettings}}", _getSettings},
+		{"{{getCurrentValue}}", _getCurrentValue},
 		{"{{regex}}", _regex},
 	};
 
-	QHBoxLayout *line1Layout = new QHBoxLayout;
+	auto entryLayout = new QHBoxLayout;
+	PlaceWidgets(obs_module_text(
+			     "AdvSceneSwitcher.condition.sceneTransform.entry"),
+		     entryLayout, widgetPlaceholders);
 	PlaceWidgets(
 		obs_module_text(
-			"AdvSceneSwitcher.condition.sceneTransform.entry.line1"),
-		line1Layout, widgetPlaceholders);
-	QHBoxLayout *line2Layout = new QHBoxLayout;
+			"AdvSceneSwitcher.condition.sceneTransform.entry.singleSettingCompare"),
+		_compareLayout, widgetPlaceholders, false);
+	auto optionsLayout = new QHBoxLayout;
 	PlaceWidgets(
 		obs_module_text(
-			"AdvSceneSwitcher.condition.sceneTransform.entry.line2"),
-		line2Layout, widgetPlaceholders, false);
-	QHBoxLayout *line3Layout = new QHBoxLayout;
-	PlaceWidgets(
-		obs_module_text(
-			"AdvSceneSwitcher.condition.sceneTransform.entry.line3"),
-		line3Layout, widgetPlaceholders);
+			"AdvSceneSwitcher.condition.sceneTransform.entry.options"),
+		optionsLayout, widgetPlaceholders);
 
 	QVBoxLayout *mainLayout = new QVBoxLayout;
-	mainLayout->addLayout(line1Layout);
-	mainLayout->addLayout(line2Layout);
-	mainLayout->addLayout(line3Layout);
+	mainLayout->addLayout(entryLayout);
+	mainLayout->addLayout(_compareLayout);
+	mainLayout->addWidget(_transformString);
+	mainLayout->addLayout(optionsLayout);
 	setLayout(mainLayout);
 
 	_entryData = entryData;
@@ -217,52 +431,75 @@ void MacroConditionSceneTransformEdit::UpdateEntryData()
 
 	_scenes->SetScene(_entryData->_scene);
 	_sources->SetSceneItem(_entryData->_source);
-	_types->setCurrentIndex(static_cast<int>(_entryData->_type));
+	_settingsType->setCurrentIndex(
+		static_cast<int>(_entryData->GetSettingsType()));
+	_compare->setCurrentIndex(static_cast<int>(_entryData->_compare));
+	_conditions->setCurrentIndex(
+		static_cast<int>(_entryData->GetCondition()));
 	_regex->SetRegexConfig(_entryData->_regex);
-	_settings->setPlainText(_entryData->_settings);
+	UpdateSettingSelection();
+	_settingSelection->SetSetting(_entryData->_setting);
+	_transformString->setPlainText(_entryData->_transformString);
+	_singleSettingValue->setText(_entryData->_singleSetting);
 	SetWidgetVisibility();
 }
 
 void MacroConditionSceneTransformEdit::SceneChanged(const SceneSelection &s)
 {
-	if (_loading || !_entryData) {
-		return;
+	{
+		GUARD_LOADING_AND_LOCK();
+		_entryData->_scene = s;
 	}
-
-	auto lock = LockContext();
-	_entryData->_scene = s;
+	UpdateSettingSelection();
 }
 
 void MacroConditionSceneTransformEdit::SourceChanged(
 	const SceneItemSelection &item)
 {
-	if (_loading || !_entryData) {
-		return;
+	{
+		GUARD_LOADING_AND_LOCK();
+		_entryData->_source = item;
 	}
 
-	auto lock = LockContext();
-	_entryData->_source = item;
+	UpdateSettingSelection();
 	emit HeaderInfoChanged(
 		QString::fromStdString(_entryData->GetShortDesc()));
 	adjustSize();
 	updateGeometry();
 }
 
-void MacroConditionSceneTransformEdit::TypeChanged(int index)
+void MacroConditionSceneTransformEdit::SettingsTypeChanged(int type)
 {
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	auto lock = LockContext();
-	_entryData->_type =
-		static_cast<MacroConditionSceneTransform::CondType>(index);
+	GUARD_LOADING_AND_LOCK();
+	_entryData->SetSettingsType(
+		static_cast<MacroConditionSceneTransform::SettingsType>(type));
 	SetWidgetVisibility();
 }
 
+void MacroConditionSceneTransformEdit::CompareChanged(int type)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_compare =
+		static_cast<MacroConditionSceneTransform::Compare>(type);
+}
+
+void MacroConditionSceneTransformEdit::ConditionChanged(int index)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->SetCondition(
+		static_cast<MacroConditionSceneTransform::Condition>(index));
+	SetWidgetVisibility();
+}
+
+void MacroConditionSceneTransformEdit::SettingSelectionChanged(
+	const TransformSetting &setting)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_setting = setting;
+}
+
 void MacroConditionSceneTransformEdit::GetSettingsClicked()
 {
-
 	if (_loading || !_entryData || !_entryData->_scene.GetScene(false)) {
 		return;
 	}
@@ -276,17 +513,47 @@ void MacroConditionSceneTransformEdit::GetSettingsClicked()
 	if (_entryData->_regex.Enabled()) {
 		settings = EscapeForRegex(settings);
 	}
-	_settings->setPlainText(settings);
+	_transformString->setPlainText(settings);
+
+	adjustSize();
+	updateGeometry();
 }
 
-void MacroConditionSceneTransformEdit::SettingsChanged()
+void MacroConditionSceneTransformEdit::GetCurrentValueClicked()
 {
-	if (_loading || !_entryData) {
+	if (_loading || !_entryData || !_entryData->_scene.GetScene(false)) {
 		return;
 	}
 
-	auto lock = LockContext();
-	_entryData->_settings = _settings->toPlainText().toStdString();
+	auto items = _entryData->_source.GetSceneItems(_entryData->_scene);
+	if (items.empty()) {
+		return;
+	}
+
+	auto value =
+		GetTransformSettingValue(items.at(0), _entryData->_setting);
+	if (!value) {
+		return;
+	}
+
+	_singleSettingValue->setText(QString::fromStdString(*value));
+	SettingValueChanged();
+}
+
+void MacroConditionSceneTransformEdit::TransformChanged()
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_transformString =
+		_transformString->toPlainText().toStdString();
+
+	adjustSize();
+	updateGeometry();
+}
+
+void MacroConditionSceneTransformEdit::SettingValueChanged()
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_singleSetting = _singleSettingValue->text().toStdString();
 
 	adjustSize();
 	updateGeometry();
@@ -294,11 +561,7 @@ void MacroConditionSceneTransformEdit::SettingsChanged()
 
 void MacroConditionSceneTransformEdit::RegexChanged(const RegexConfig &conf)
 {
-	if (_loading || !_entryData) {
-		return;
-	}
-
-	auto lock = LockContext();
+	GUARD_LOADING_AND_LOCK();
 	_entryData->_regex = conf;
 
 	adjustSize();
@@ -307,14 +570,61 @@ void MacroConditionSceneTransformEdit::RegexChanged(const RegexConfig &conf)
 
 void MacroConditionSceneTransformEdit::SetWidgetVisibility()
 {
-	const bool showSettingsAndRegex =
-		_entryData->_type ==
-		MacroConditionSceneTransform::CondType::MATCHES;
-	_settings->setVisible(showSettingsAndRegex);
-	_getSettings->setVisible(showSettingsAndRegex);
-	_regex->setVisible(showSettingsAndRegex);
+	const auto condition = _entryData->GetCondition();
+	const auto settingsType = _entryData->GetSettingsType();
+	_transformString->setVisible(
+		condition == MacroConditionSceneTransform::Condition::MATCHES);
+	_regex->setVisible(
+		condition == MacroConditionSceneTransform::Condition::MATCHES &&
+		settingsType ==
+			MacroConditionSceneTransform::SettingsType::ALL);
+	_getSettings->setVisible(
+		condition == MacroConditionSceneTransform::Condition::MATCHES &&
+		settingsType ==
+			MacroConditionSceneTransform::SettingsType::ALL);
+	_getCurrentValue->setVisible(
+		condition == MacroConditionSceneTransform::Condition::MATCHES &&
+		settingsType ==
+			MacroConditionSceneTransform::SettingsType::SINGLE);
+	SetLayoutVisible(
+		_compareLayout,
+		condition == MacroConditionSceneTransform::Condition::MATCHES &&
+			settingsType == MacroConditionSceneTransform::
+						SettingsType::SINGLE);
+	_settingSelection->setVisible(
+		settingsType ==
+		MacroConditionSceneTransform::SettingsType::SINGLE);
+	if (condition == MacroConditionSceneTransform::Condition::MATCHES &&
+	    settingsType ==
+		    MacroConditionSceneTransform::SettingsType::SINGLE) {
+		RemoveStretchIfPresent(_compareLayout);
+	} else if (condition ==
+			   MacroConditionSceneTransform::Condition::CHANGED &&
+		   settingsType ==
+			   MacroConditionSceneTransform::SettingsType::SINGLE) {
+		AddStretchIfNecessary(_compareLayout);
+	}
+	_transformString->setVisible(
+		condition == MacroConditionSceneTransform::Condition::MATCHES &&
+		settingsType ==
+			MacroConditionSceneTransform::SettingsType::ALL);
+
 	adjustSize();
 	updateGeometry();
 }
 
+void MacroConditionSceneTransformEdit::UpdateSettingSelection() const
+{
+	if (!_entryData) {
+		_settingSelection->SetSource(nullptr);
+		return;
+	}
+	auto items = _entryData->_source.GetSceneItems(_entryData->_scene);
+	if (items.empty()) {
+		_settingSelection->SetSource(nullptr);
+		return;
+	}
+	_settingSelection->SetSource(items.at(0));
+}
+
 } // namespace advss

plugins/base/macro-condition-scene-transform.hpp

@@ -1,9 +1,10 @@
 #pragma once
 #include "macro-condition-edit.hpp"
-#include "scene-selection.hpp"
-#include "scene-item-selection.hpp"
-#include "variable-text-edit.hpp"
 #include "regex-config.hpp"
+#include "scene-item-selection.hpp"
+#include "scene-selection.hpp"
+#include "transform-setting.hpp"
+#include "variable-text-edit.hpp"
 
 #include <QSpinBox>
 #include <QCheckBox>
@@ -23,19 +24,38 @@ public:
 		return std::make_shared<MacroConditionSceneTransform>(m);
 	}
 
-	enum class CondType {
-		MATCHES,
-		CHANGED,
-	};
+	enum class SettingsType { ALL, SINGLE };
+	enum class Condition { MATCHES, CHANGED };
+	enum class Compare { LESS, EQUAL, MORE };
+
+	void SetSettingsType(SettingsType type);
+	SettingsType GetSettingsType() const { return _settingsType; }
+	void SetCondition(Condition condition);
+	Condition GetCondition() const { return _condition; }
 
 	SceneSelection _scene;
 	SceneItemSelection _source;
-	CondType _type = CondType::MATCHES;
+	Compare _compare = Compare::EQUAL;
 	RegexConfig _regex;
-	StringVariable _settings = "";
+	StringVariable _transformString = "";
+	StringVariable _singleSetting = "";
+	TransformSetting _setting;
 
 private:
+	void SetupTempVars();
+	bool CheckAllSettings(const std::vector<OBSSceneItem> &);
+	bool CheckSingleSetting(const std::vector<OBSSceneItem> &);
+	bool
+	AnySceneItemTransformSettingChanged(const std::vector<OBSSceneItem> &);
+	bool
+	AnySceneItemTransformSettingMatches(const std::vector<OBSSceneItem> &);
+	void SetTempVarHelper(const std::vector<std::string> &values);
+
+	SettingsType _settingsType = SettingsType::SINGLE;
+	Condition _condition = Condition::MATCHES;
+
 	std::vector<std::string> _previousTransform;
+	std::vector<std::string> _previousSettingValues;
 
 	static bool _registered;
 	static const std::string id;
@@ -62,25 +82,36 @@ public:
 private slots:
 	void SceneChanged(const SceneSelection &);
 	void SourceChanged(const SceneItemSelection &);
-	void TypeChanged(int type);
+	void SettingsTypeChanged(int type);
+	void CompareChanged(int type);
+	void ConditionChanged(int type);
+	void SettingSelectionChanged(const TransformSetting &);
 	void GetSettingsClicked();
-	void SettingsChanged();
+	void GetCurrentValueClicked();
+	void TransformChanged();
+	void SettingValueChanged();
 	void RegexChanged(const RegexConfig &);
 signals:
 	void HeaderInfoChanged(const QString &);
 
-protected:
-	SceneSelectionWidget *_scenes;
-	SceneItemSelectionWidget *_sources;
-	QComboBox *_types;
-	QPushButton *_getSettings;
-	VariableTextEdit *_settings;
-	RegexConfigWidget *_regex;
-
-	std::shared_ptr<MacroConditionSceneTransform> _entryData;
-
 private:
 	void SetWidgetVisibility();
+	void UpdateSettingSelection() const;
+
+	SceneSelectionWidget *_scenes;
+	SceneItemSelectionWidget *_sources;
+	QComboBox *_settingsType;
+	QComboBox *_compare;
+	QComboBox *_conditions;
+	QPushButton *_getSettings;
+	QPushButton *_getCurrentValue;
+	VariableTextEdit *_transformString;
+	VariableLineEdit *_singleSettingValue;
+	RegexConfigWidget *_regex;
+	TransformSettingSelection *_settingSelection;
+	QHBoxLayout *_compareLayout;
+
+	std::shared_ptr<MacroConditionSceneTransform> _entryData;
 	bool _loading = true;
 };