Cleanup

* Reorder action type selection
* Refactor

data/locale/en-US.ini

@@ -1054,7 +1054,7 @@ AdvSceneSwitcher.action.http.type.post="POST"
 AdvSceneSwitcher.action.http.entry.line1="Send{{method}}to{{url}}"
 AdvSceneSwitcher.action.http.entry.line2="Timeout:{{timeout}}seconds"
 AdvSceneSwitcher.action.variable="Variable"
-AdvSceneSwitcher.action.variable.type.set="Set to fixed value"
+AdvSceneSwitcher.action.variable.type.set="Set to value"
 AdvSceneSwitcher.action.variable.type.append="Append"
 AdvSceneSwitcher.action.variable.type.appendVar="Append variable"
 AdvSceneSwitcher.action.variable.type.increment="Increment"

lib/macro/macro-action-variable.cpp

@@ -19,68 +19,6 @@ bool MacroActionVariable::_registered = MacroActionFactory::Register(
 	{MacroActionVariable::Create, MacroActionVariableEdit::Create,
 	 "AdvSceneSwitcher.action.variable"});
 
-const static std::map<MacroActionVariable::Type, std::string> actionTypes = {
-	{MacroActionVariable::Type::SET_FIXED_VALUE,
-	 "AdvSceneSwitcher.action.variable.type.set"},
-	{MacroActionVariable::Type::APPEND,
-	 "AdvSceneSwitcher.action.variable.type.append"},
-	{MacroActionVariable::Type::APPEND_VAR,
-	 "AdvSceneSwitcher.action.variable.type.appendVar"},
-	{MacroActionVariable::Type::INCREMENT,
-	 "AdvSceneSwitcher.action.variable.type.increment"},
-	{MacroActionVariable::Type::DECREMENT,
-	 "AdvSceneSwitcher.action.variable.type.decrement"},
-	{MacroActionVariable::Type::SET_CONDITION_VALUE,
-	 "AdvSceneSwitcher.action.variable.type.setConditionValue"},
-	{MacroActionVariable::Type::SET_ACTION_VALUE,
-	 "AdvSceneSwitcher.action.variable.type.setActionValue"},
-	{MacroActionVariable::Type::ROUND_TO_INT,
-	 "AdvSceneSwitcher.action.variable.type.roundToInt"},
-	{MacroActionVariable::Type::SUBSTRING,
-	 "AdvSceneSwitcher.action.variable.type.subString"},
-	{MacroActionVariable::Type::FIND_AND_REPLACE,
-	 "AdvSceneSwitcher.action.variable.type.findAndReplace"},
-	{MacroActionVariable::Type::MATH_EXPRESSION,
-	 "AdvSceneSwitcher.action.variable.type.mathExpression"},
-	{MacroActionVariable::Type::USER_INPUT,
-	 "AdvSceneSwitcher.action.variable.type.askForValue"},
-	{MacroActionVariable::Type::ENV_VARIABLE,
-	 "AdvSceneSwitcher.action.variable.type.environmentVariable"},
-	{MacroActionVariable::Type::SCENE_ITEM_COUNT,
-	 "AdvSceneSwitcher.action.variable.type.sceneItemCount"},
-	{MacroActionVariable::Type::STRING_LENGTH,
-	 "AdvSceneSwitcher.action.variable.type.stringLength"},
-	{MacroActionVariable::Type::EXTRACT_JSON,
-	 "AdvSceneSwitcher.action.variable.type.extractJson"},
-	{MacroActionVariable::Type::SET_TO_TEMPVAR,
-	 "AdvSceneSwitcher.action.variable.type.setToTempvar"},
-	{MacroActionVariable::Type::SCENE_ITEM_NAME,
-	 "AdvSceneSwitcher.action.variable.type.sceneItemName"},
-	{MacroActionVariable::Type::PAD,
-	 "AdvSceneSwitcher.action.variable.type.padValue"},
-	{MacroActionVariable::Type::TRUNCATE,
-	 "AdvSceneSwitcher.action.variable.type.truncateValue"},
-	{MacroActionVariable::Type::SWAP_VALUES,
-	 "AdvSceneSwitcher.action.variable.type.swapValues"},
-	{MacroActionVariable::Type::TRIM,
-	 "AdvSceneSwitcher.action.variable.type.trim"},
-	{MacroActionVariable::Type::CHANGE_CASE,
-	 "AdvSceneSwitcher.action.variable.type.changeCase"},
-	{MacroActionVariable::Type::RANDOM_NUMBER,
-	 "AdvSceneSwitcher.action.variable.type.randomNumber"},
-};
-
-const static std::map<MacroActionVariable::CaseType, std::string> caseTypes = {
-	{MacroActionVariable::CaseType::LOWER_CASE,
-	 "AdvSceneSwitcher.action.variable.case.type.lowerCase"},
-	{MacroActionVariable::CaseType::UPPER_CASE,
-	 "AdvSceneSwitcher.action.variable.case.type.upperCase"},
-	{MacroActionVariable::CaseType::CAPITALIZED,
-	 "AdvSceneSwitcher.action.variable.case.type.capitalized"},
-	{MacroActionVariable::CaseType::START_CASE,
-	 "AdvSceneSwitcher.action.variable.case.type.startCase"},
-};
-
 static void apppend(Variable &var, const std::string &value)
 {
 	auto currentValue = var.Value();
@@ -338,14 +276,14 @@ bool MacroActionVariable::PerformAction()
 		return true;
 	}
 
-	switch (_type) {
-	case Type::SET_FIXED_VALUE:
+	switch (_action) {
+	case Action::SET_VALUE:
 		var->SetValue(_strValue);
 		break;
-	case Type::APPEND:
+	case Action::APPEND:
 		apppend(*var, _strValue);
 		break;
-	case Type::APPEND_VAR: {
+	case Action::APPEND_VAR: {
 		auto var2 = _variable2.lock();
 		if (!var2) {
 			return true;
@@ -353,14 +291,14 @@ bool MacroActionVariable::PerformAction()
 		apppend(*var, var2->Value());
 		break;
 	}
-	case Type::INCREMENT:
+	case Action::INCREMENT:
 		modifyNumValue(*var, _numValue.GetValue(), true);
 		break;
-	case Type::DECREMENT:
+	case Action::DECREMENT:
 		modifyNumValue(*var, _numValue.GetValue(), false);
 		break;
-	case Type::SET_CONDITION_VALUE:
-	case Type::SET_ACTION_VALUE: {
+	case Action::SET_CONDITION_VALUE:
+	case Action::SET_ACTION_VALUE: {
 		auto m = GetMacro();
 		if (!m) {
 			return true;
@@ -375,7 +313,7 @@ bool MacroActionVariable::PerformAction()
 		var->SetValue(segment->GetVariableValue());
 		break;
 	}
-	case Type::ROUND_TO_INT: {
+	case Action::ROUND_TO_INT: {
 		auto curValue = var->DoubleValue();
 		if (!curValue.has_value()) {
 			return true;
@@ -383,7 +321,7 @@ bool MacroActionVariable::PerformAction()
 		var->SetValue(std::to_string(int(std::round(*curValue))));
 		return true;
 	}
-	case Type::SUBSTRING: {
+	case Action::SUBSTRING: {
 		if (_subStringRegex.Enabled()) {
 			HandleRegexSubString(var.get());
 			return true;
@@ -391,15 +329,15 @@ bool MacroActionVariable::PerformAction()
 		HandleIndexSubString(var.get());
 		return true;
 	}
-	case Type::FIND_AND_REPLACE: {
+	case Action::FIND_AND_REPLACE: {
 		HandleFindAndReplace(var.get());
 		return true;
 	}
-	case Type::MATH_EXPRESSION: {
+	case Action::MATH_EXPRESSION: {
 		HandleMathExpression(var.get());
 		return true;
 	}
-	case Type::USER_INPUT: {
+	case Action::USER_INPUT: {
 		auto params = std::make_shared<AskForInputParams>(
 			_useCustomPrompt
 				? QString::fromStdString(_inputPrompt)
@@ -424,22 +362,22 @@ bool MacroActionVariable::PerformAction()
 		var->SetValue(*params->result);
 		return true;
 	}
-	case Type::ENV_VARIABLE: {
+	case Action::ENV_VARIABLE: {
 		auto value = std::getenv(_envVariableName.c_str());
 		if (value) {
 			var->SetValue(value);
 		}
 		return true;
 	}
-	case Type::SCENE_ITEM_COUNT: {
+	case Action::SCENE_ITEM_COUNT: {
 		var->SetValue(GetSceneItemCount(_scene.GetScene(false)));
 		return true;
 	}
-	case Type::STRING_LENGTH: {
+	case Action::STRING_LENGTH: {
 		var->SetValue(std::string(_strValue).length());
 		return true;
 	}
-	case Type::EXTRACT_JSON: {
+	case Action::EXTRACT_JSON: {
 		auto value = GetJsonField(var->Value(), _strValue);
 		if (!value.has_value()) {
 			return true;
@@ -447,7 +385,7 @@ bool MacroActionVariable::PerformAction()
 		var->SetValue(*value);
 		return true;
 	}
-	case Type::SET_TO_TEMPVAR: {
+	case Action::SET_TO_TEMPVAR: {
 		auto tempVar = _tempVar.GetTempVariable(GetMacro());
 		if (!tempVar) {
 			return true;
@@ -459,18 +397,18 @@ bool MacroActionVariable::PerformAction()
 		var->SetValue(*value);
 		return true;
 	}
-	case Type::SCENE_ITEM_NAME:
+	case Action::SCENE_ITEM_NAME:
 		SetToSceneItemName(var.get());
 		return true;
-	case Type::PAD:
+	case Action::PAD:
 		var->SetValue(pad(var->Value(), _direction, _stringLength,
 				  _paddingChar));
 		return true;
-	case Type::TRUNCATE:
+	case Action::TRUNCATE:
 		var->SetValue(
 			truncate(var->Value(), _direction, _stringLength));
 		return true;
-	case Type::SWAP_VALUES: {
+	case Action::SWAP_VALUES: {
 		auto var2 = _variable2.lock();
 		if (!var2) {
 			return true;
@@ -481,16 +419,16 @@ bool MacroActionVariable::PerformAction()
 		var2->SetValue(tempValue);
 		return true;
 	}
-	case Type::TRIM: {
+	case Action::TRIM: {
 		var->SetValue(QString::fromStdString(var->Value())
 				      .trimmed()
 				      .toStdString());
 		return true;
 	}
-	case Type::CHANGE_CASE:
+	case Action::CHANGE_CASE:
 		HandleCaseChange(var.get());
 		return true;
-	case Type::RANDOM_NUMBER:
+	case Action::RANDOM_NUMBER:
 		GenerateRandomNumber(var.get());
 		return true;
 	}
@@ -507,7 +445,7 @@ bool MacroActionVariable::Save(obs_data_t *obj) const
 			    GetWeakVariableName(_variable2).c_str());
 	_strValue.Save(obj, "strValue");
 	_numValue.Save(obj, "numValue");
-	obs_data_set_int(obj, "condition", static_cast<int>(_type));
+	obs_data_set_int(obj, "condition", static_cast<int>(_action));
 	obs_data_set_int(obj, "segmentIdx", GetSegmentIndexValue());
 	_subStringStart.Save(obj, "subStringStart");
 	_subStringSize.Save(obj, "subStringSize");
@@ -547,7 +485,7 @@ bool MacroActionVariable::Load(obs_data_t *obj)
 	_variable2 = GetWeakVariableByName(
 		obs_data_get_string(obj, "variable2Name"));
 	_strValue.Load(obj, "strValue");
-	_type = static_cast<Type>(obs_data_get_int(obj, "condition"));
+	_action = static_cast<Action>(obs_data_get_int(obj, "condition"));
 	_segmentIdxLoadValue = obs_data_get_int(obj, "segmentIdx");
 	_subStringRegex.Load(obj);
 	_regexPattern = obs_data_get_string(obj, "regexPattern");
@@ -630,11 +568,11 @@ void MacroActionVariable::SetSegmentIndexValue(int value)
 	}
 
 	std::shared_ptr<MacroSegment> segment;
-	if (_type == Type::SET_CONDITION_VALUE) {
+	if (_action == Action::SET_CONDITION_VALUE) {
 		if (value < (int)m->Conditions().size()) {
 			segment = m->Conditions().at(value);
 		}
-	} else if (_type == Type::SET_ACTION_VALUE) {
+	} else if (_action == Action::SET_ACTION_VALUE) {
 		if (value < (int)m->Actions().size()) {
 			segment = m->Actions().at(value);
 		}
@@ -658,14 +596,14 @@ int MacroActionVariable::GetSegmentIndexValue() const
 		return -1;
 	}
 
-	if (_type == Type::SET_CONDITION_VALUE) {
+	if (_action == Action::SET_CONDITION_VALUE) {
 		auto it = std::find(m->Conditions().begin(),
 				    m->Conditions().end(), segment);
 		if (it != m->Conditions().end()) {
 			return std::distance(m->Conditions().begin(), it);
 		}
 		return -1;
-	} else if (_type == Type::SET_ACTION_VALUE) {
+	} else if (_action == Action::SET_ACTION_VALUE) {
 		auto it = std::find(m->Actions().begin(), m->Actions().end(),
 				    segment);
 		if (it != m->Actions().end()) {
@@ -700,16 +638,99 @@ void MacroActionVariable::DecrementCurrentSegmentVariableRef()
 	DecrementVariableRef(segment.get());
 }
 
-static inline void populateTypeSelection(QComboBox *list)
+static inline void populateActionSelection(QComboBox *list)
 {
-	for (const auto &[action, name] : actionTypes) {
-		list->addItem(obs_module_text(name.c_str()),
-			      static_cast<int>(action));
+	static const std::vector<std::pair<
+		std::variant<MacroActionVariable::Action, bool>, std::string>>
+		actions = {
+			{MacroActionVariable::Action::SET_VALUE,
+			 "AdvSceneSwitcher.action.variable.type.set"},
+			{MacroActionVariable::Action::APPEND,
+			 "AdvSceneSwitcher.action.variable.type.append"},
+			{MacroActionVariable::Action::PAD,
+			 "AdvSceneSwitcher.action.variable.type.padValue"},
+			{MacroActionVariable::Action::TRUNCATE,
+			 "AdvSceneSwitcher.action.variable.type.truncateValue"},
+			{MacroActionVariable::Action::SUBSTRING,
+			 "AdvSceneSwitcher.action.variable.type.subString"},
+			{MacroActionVariable::Action::FIND_AND_REPLACE,
+			 "AdvSceneSwitcher.action.variable.type.findAndReplace"},
+			{MacroActionVariable::Action::EXTRACT_JSON,
+			 "AdvSceneSwitcher.action.variable.type.extractJson"},
+			{MacroActionVariable::Action::STRING_LENGTH,
+			 "AdvSceneSwitcher.action.variable.type.stringLength"},
+			{MacroActionVariable::Action::TRIM,
+			 "AdvSceneSwitcher.action.variable.type.trim"},
+			{MacroActionVariable::Action::CHANGE_CASE,
+			 "AdvSceneSwitcher.action.variable.type.changeCase"},
+			{true, ""}, // Separator
+
+			{MacroActionVariable::Action::SET_TO_TEMPVAR,
+			 "AdvSceneSwitcher.action.variable.type.setToTempvar"},
+			{MacroActionVariable::Action::SET_CONDITION_VALUE,
+			 "AdvSceneSwitcher.action.variable.type.setConditionValue"},
+			{MacroActionVariable::Action::SET_ACTION_VALUE,
+			 "AdvSceneSwitcher.action.variable.type.setActionValue"},
+			{true, ""}, // Separator
+
+			{MacroActionVariable::Action::MATH_EXPRESSION,
+			 "AdvSceneSwitcher.action.variable.type.mathExpression"},
+			{MacroActionVariable::Action::INCREMENT,
+			 "AdvSceneSwitcher.action.variable.type.increment"},
+			{MacroActionVariable::Action::DECREMENT,
+			 "AdvSceneSwitcher.action.variable.type.decrement"},
+			{MacroActionVariable::Action::ROUND_TO_INT,
+			 "AdvSceneSwitcher.action.variable.type.roundToInt"},
+			{MacroActionVariable::Action::RANDOM_NUMBER,
+			 "AdvSceneSwitcher.action.variable.type.randomNumber"},
+			{true, ""}, // Separator
+
+			{MacroActionVariable::Action::USER_INPUT,
+			 "AdvSceneSwitcher.action.variable.type.askForValue"},
+			{MacroActionVariable::Action::ENV_VARIABLE,
+			 "AdvSceneSwitcher.action.variable.type.environmentVariable"},
+			{true, ""}, // Separator
+
+			{MacroActionVariable::Action::SCENE_ITEM_NAME,
+			 "AdvSceneSwitcher.action.variable.type.sceneItemName"},
+			{MacroActionVariable::Action::SCENE_ITEM_COUNT,
+			 "AdvSceneSwitcher.action.variable.type.sceneItemCount"},
+			{true, ""}, // Separator
+
+			{MacroActionVariable::Action::SWAP_VALUES,
+			 "AdvSceneSwitcher.action.variable.type.swapValues"},
+			{MacroActionVariable::Action::APPEND_VAR,
+			 "AdvSceneSwitcher.action.variable.type.appendVar"},
+
+		};
+
+	for (const auto &[action, name] : actions) {
+		if (std::holds_alternative<bool>(action)) {
+			list->insertSeparator(actions.size());
+			continue;
+		}
+
+		list->addItem(
+			obs_module_text(name.c_str()),
+			static_cast<int>(
+				std::get<MacroActionVariable::Action>(action)));
 	}
 }
 
 static inline void populateCaseTypeSelection(QComboBox *list)
 {
+	const static std::map<MacroActionVariable::CaseType, std::string>
+		caseTypes = {
+			{MacroActionVariable::CaseType::LOWER_CASE,
+			 "AdvSceneSwitcher.action.variable.case.type.lowerCase"},
+			{MacroActionVariable::CaseType::UPPER_CASE,
+			 "AdvSceneSwitcher.action.variable.case.type.upperCase"},
+			{MacroActionVariable::CaseType::CAPITALIZED,
+			 "AdvSceneSwitcher.action.variable.case.type.capitalized"},
+			{MacroActionVariable::CaseType::START_CASE,
+			 "AdvSceneSwitcher.action.variable.case.type.startCase"},
+		};
+
 	for (const auto &[type, name] : caseTypes) {
 		list->addItem(obs_module_text(name.c_str()),
 			      static_cast<int>(type));
@@ -798,7 +819,7 @@ MacroActionVariableEdit::MacroActionVariableEdit(
 				    QSizePolicy::Preferred);
 	_sceneItemIndex->setMinimum(1);
 	_stringLength->setMaximum(999);
-	populateTypeSelection(_actions);
+	populateActionSelection(_actions);
 	populateDirectionSelection(_direction);
 	populateCaseTypeSelection(_caseType);
 	_randomNumberStart->setMinimum(-9999999999);
@@ -999,14 +1020,14 @@ void MacroActionVariableEdit::UpdateEntryData()
 	_variables->SetVariable(_entryData->_variable);
 	_variables2->SetVariable(_entryData->_variable2);
 	_actions->setCurrentIndex(
-		_actions->findData(static_cast<int>(_entryData->_type)));
+		_actions->findData(static_cast<int>(_entryData->_action)));
 	_strValue->setPlainText(_entryData->_strValue);
 	_numValue->SetValue(_entryData->_numValue);
 	_segmentIdx->SetValue(_entryData->GetSegmentIndexValue() + 1);
 	_segmentIdx->SetMacro(_entryData->GetMacro());
 	_segmentIdx->SetType(
-		_entryData->_type ==
-				MacroActionVariable::Type::SET_CONDITION_VALUE
+		_entryData->_action ==
+				MacroActionVariable::Action::SET_CONDITION_VALUE
 			? MacroSegmentSelection::Type::CONDITION
 			: MacroSegmentSelection::Type::ACTION);
 	_subStringStart->SetValue(_entryData->_subStringStart);
@@ -1069,13 +1090,14 @@ void MacroActionVariableEdit::ActionChanged(int idx)
 	}
 
 	auto lock = LockContext();
-	_entryData->_type = static_cast<MacroActionVariable::Type>(
+	_entryData->_action = static_cast<MacroActionVariable::Action>(
 		_actions->itemData(idx).toInt());
 
-	if (_entryData->_type == MacroActionVariable::Type::SET_ACTION_VALUE) {
+	if (_entryData->_action ==
+	    MacroActionVariable::Action::SET_ACTION_VALUE) {
 		_segmentIdx->SetType(MacroSegmentSelection::Type::ACTION);
-	} else if (_entryData->_type ==
-		   MacroActionVariable::Type::SET_CONDITION_VALUE) {
+	} else if (_entryData->_action ==
+		   MacroActionVariable::Action::SET_CONDITION_VALUE) {
 		_segmentIdx->SetType(MacroSegmentSelection::Type::CONDITION);
 	}
 	SetWidgetVisibility();
@@ -1127,10 +1149,10 @@ void MacroActionVariableEdit::SetSegmentValueError(const QString &text)
 void MacroActionVariableEdit::UpdateSegmentVariableValue()
 {
 	if (!_entryData ||
-	    !(_entryData->_type ==
-		      MacroActionVariable::Type::SET_CONDITION_VALUE ||
-	      _entryData->_type ==
-		      MacroActionVariable::Type::SET_ACTION_VALUE)) {
+	    !(_entryData->_action ==
+		      MacroActionVariable::Action::SET_CONDITION_VALUE ||
+	      _entryData->_action ==
+		      MacroActionVariable::Action::SET_ACTION_VALUE)) {
 		return;
 	}
 
@@ -1149,13 +1171,14 @@ void MacroActionVariableEdit::UpdateSegmentVariableValue()
 	}
 
 	std::shared_ptr<MacroSegment> segment;
-	if (_entryData->_type == MacroActionVariable::Type::SET_ACTION_VALUE) {
+	if (_entryData->_action ==
+	    MacroActionVariable::Action::SET_ACTION_VALUE) {
 		const auto &actions = m->Actions();
 		if (index < (int)actions.size()) {
 			segment = actions.at(index);
 		}
-	} else if (_entryData->_type ==
-		   MacroActionVariable::Type::SET_CONDITION_VALUE) {
+	} else if (_entryData->_action ==
+		   MacroActionVariable::Action::SET_CONDITION_VALUE) {
 		const auto &conditions = m->Conditions();
 		if (index < (int)conditions.size()) {
 			segment = conditions.at(index);
@@ -1172,14 +1195,14 @@ void MacroActionVariableEdit::UpdateSegmentVariableValue()
 		std::string type;
 		QString fmt;
 
-		if (_entryData->_type ==
-		    MacroActionVariable::Type::SET_ACTION_VALUE) {
+		if (_entryData->_action ==
+		    MacroActionVariable::Action::SET_ACTION_VALUE) {
 			type = MacroActionFactory::GetActionName(
 				segment->GetId());
 			fmt = QString(obs_module_text(
 				"AdvSceneSwitcher.action.variable.actionNoVariableSupport"));
-		} else if (_entryData->_type ==
-			   MacroActionVariable::Type::SET_CONDITION_VALUE) {
+		} else if (_entryData->_action ==
+			   MacroActionVariable::Action::SET_CONDITION_VALUE) {
 			type = MacroConditionFactory::GetConditionName(
 				segment->GetId());
 			fmt = QString(obs_module_text(
@@ -1504,10 +1527,11 @@ void MacroActionVariableEdit::SetWidgetVisibility()
 	};
 
 	const char *layoutString = "";
-	if (_entryData->_type == MacroActionVariable::Type::PAD) {
+	if (_entryData->_action == MacroActionVariable::Action::PAD) {
 		layoutString = obs_module_text(
 			"AdvSceneSwitcher.action.variable.entry.pad");
-	} else if (_entryData->_type == MacroActionVariable::Type::TRUNCATE) {
+	} else if (_entryData->_action ==
+		   MacroActionVariable::Action::TRUNCATE) {
 		layoutString = obs_module_text(
 			"AdvSceneSwitcher.action.variable.entry.truncate");
 	} else {
@@ -1522,64 +1546,70 @@ void MacroActionVariableEdit::SetWidgetVisibility()
 	ClearLayout(_entryLayout);
 	PlaceWidgets(layoutString, _entryLayout, widgetPlaceholders);
 
-	if (_entryData->_type == MacroActionVariable::Type::SET_FIXED_VALUE ||
-	    _entryData->_type == MacroActionVariable::Type::APPEND ||
-	    _entryData->_type == MacroActionVariable::Type::MATH_EXPRESSION ||
-	    _entryData->_type == MacroActionVariable::Type::ENV_VARIABLE ||
-	    _entryData->_type == MacroActionVariable::Type::STRING_LENGTH ||
-	    _entryData->_type == MacroActionVariable::Type::EXTRACT_JSON) {
+	if (_entryData->_action == MacroActionVariable::Action::SET_VALUE ||
+	    _entryData->_action == MacroActionVariable::Action::APPEND ||
+	    _entryData->_action ==
+		    MacroActionVariable::Action::MATH_EXPRESSION ||
+	    _entryData->_action == MacroActionVariable::Action::ENV_VARIABLE ||
+	    _entryData->_action == MacroActionVariable::Action::STRING_LENGTH ||
+	    _entryData->_action == MacroActionVariable::Action::EXTRACT_JSON) {
 		RemoveStretchIfPresent(_entryLayout);
 	} else {
 		AddStretchIfNecessary(_entryLayout);
 	}
 
 	_variables2->setVisible(
-		_entryData->_type == MacroActionVariable::Type::APPEND_VAR ||
-		_entryData->_type == MacroActionVariable::Type::SWAP_VALUES);
+		_entryData->_action ==
+			MacroActionVariable::Action::APPEND_VAR ||
+		_entryData->_action ==
+			MacroActionVariable::Action::SWAP_VALUES);
 	_strValue->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_FIXED_VALUE ||
-		_entryData->_type == MacroActionVariable::Type::APPEND ||
-		_entryData->_type == MacroActionVariable::Type::STRING_LENGTH ||
-		_entryData->_type == MacroActionVariable::Type::EXTRACT_JSON);
+		_entryData->_action == MacroActionVariable::Action::SET_VALUE ||
+		_entryData->_action == MacroActionVariable::Action::APPEND ||
+		_entryData->_action ==
+			MacroActionVariable::Action::STRING_LENGTH ||
+		_entryData->_action ==
+			MacroActionVariable::Action::EXTRACT_JSON);
 	_numValue->setVisible(
-		_entryData->_type == MacroActionVariable::Type::INCREMENT ||
-		_entryData->_type == MacroActionVariable::Type::DECREMENT);
+		_entryData->_action == MacroActionVariable::Action::INCREMENT ||
+		_entryData->_action == MacroActionVariable::Action::DECREMENT);
 	_segmentValueStatus->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_ACTION_VALUE ||
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_CONDITION_VALUE);
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_ACTION_VALUE ||
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_CONDITION_VALUE);
 	_segmentValue->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_ACTION_VALUE ||
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_CONDITION_VALUE);
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_ACTION_VALUE ||
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_CONDITION_VALUE);
 	_segmentIdx->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_ACTION_VALUE ||
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_CONDITION_VALUE);
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_ACTION_VALUE ||
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_CONDITION_VALUE);
 	SetLayoutVisible(_substringLayout,
-			 _entryData->_type ==
-				 MacroActionVariable::Type::SUBSTRING);
-	if (_entryData->_type == MacroActionVariable::Type::SUBSTRING) {
+			 _entryData->_action ==
+				 MacroActionVariable::Action::SUBSTRING);
+	if (_entryData->_action == MacroActionVariable::Action::SUBSTRING) {
 		bool showRegex = _entryData->_subStringRegex.Enabled();
 		SetLayoutVisible(_subStringIndexEntryLayout, !showRegex);
 		SetLayoutVisible(_subStringRegexEntryLayout, showRegex);
 		_regexPattern->setVisible(showRegex);
 	}
 	SetLayoutVisible(_findReplaceLayout,
-			 _entryData->_type ==
-				 MacroActionVariable::Type::FIND_AND_REPLACE);
-	_mathExpression->setVisible(_entryData->_type ==
-				    MacroActionVariable::Type::MATH_EXPRESSION);
+			 _entryData->_action ==
+				 MacroActionVariable::Action::FIND_AND_REPLACE);
+	_mathExpression->setVisible(
+		_entryData->_action ==
+		MacroActionVariable::Action::MATH_EXPRESSION);
 	_mathExpressionResult->hide();
 	SetLayoutVisible(_promptLayout,
-			 _entryData->_type ==
-				 MacroActionVariable::Type::USER_INPUT);
+			 _entryData->_action ==
+				 MacroActionVariable::Action::USER_INPUT);
 	_inputPrompt->setVisible(
-		_entryData->_type == MacroActionVariable::Type::USER_INPUT &&
+		_entryData->_action ==
+			MacroActionVariable::Action::USER_INPUT &&
 		_entryData->_useCustomPrompt);
 	if (_entryData->_useCustomPrompt) {
 		RemoveStretchIfPresent(_promptLayout);
@@ -1588,13 +1618,16 @@ void MacroActionVariableEdit::SetWidgetVisibility()
 	}
 	SetLayoutVisible(
 		_placeholderLayout,
-		_entryData->_type == MacroActionVariable::Type::USER_INPUT &&
+		_entryData->_action ==
+				MacroActionVariable::Action::USER_INPUT &&
 			_entryData->_useCustomPrompt);
 	_useInputPlaceholder->setVisible(
-		_entryData->_type == MacroActionVariable::Type::USER_INPUT &&
+		_entryData->_action ==
+			MacroActionVariable::Action::USER_INPUT &&
 		_entryData->_useCustomPrompt);
 	_inputPlaceholder->setVisible(
-		_entryData->_type == MacroActionVariable::Type::USER_INPUT &&
+		_entryData->_action ==
+			MacroActionVariable::Action::USER_INPUT &&
 		_entryData->_useCustomPrompt &&
 		_entryData->_useInputPlaceholder);
 	if (_entryData->_useInputPlaceholder) {
@@ -1602,34 +1635,35 @@ void MacroActionVariableEdit::SetWidgetVisibility()
 	} else {
 		AddStretchIfNecessary(_placeholderLayout);
 	}
-	_envVariable->setVisible(_entryData->_type ==
-				 MacroActionVariable::Type::ENV_VARIABLE);
+	_envVariable->setVisible(_entryData->_action ==
+				 MacroActionVariable::Action::ENV_VARIABLE);
 	_scenes->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SCENE_ITEM_COUNT ||
-		_entryData->_type ==
-			MacroActionVariable::Type::SCENE_ITEM_NAME);
-	_tempVars->setVisible(_entryData->_type ==
-			      MacroActionVariable::Type::SET_TO_TEMPVAR);
+		_entryData->_action ==
+			MacroActionVariable::Action::SCENE_ITEM_COUNT ||
+		_entryData->_action ==
+			MacroActionVariable::Action::SCENE_ITEM_NAME);
+	_tempVars->setVisible(_entryData->_action ==
+			      MacroActionVariable::Action::SET_TO_TEMPVAR);
 	_tempVarsHelp->setVisible(
-		_entryData->_type ==
-			MacroActionVariable::Type::SET_TO_TEMPVAR &&
+		_entryData->_action ==
+			MacroActionVariable::Action::SET_TO_TEMPVAR &&
 		!_entryData->_tempVar.HasValidID());
-	_sceneItemIndex->setVisible(_entryData->_type ==
-				    MacroActionVariable::Type::SCENE_ITEM_NAME);
+	_sceneItemIndex->setVisible(
+		_entryData->_action ==
+		MacroActionVariable::Action::SCENE_ITEM_NAME);
 	_direction->setVisible(
-		_entryData->_type == MacroActionVariable::Type::PAD ||
-		_entryData->_type == MacroActionVariable::Type::TRUNCATE);
+		_entryData->_action == MacroActionVariable::Action::PAD ||
+		_entryData->_action == MacroActionVariable::Action::TRUNCATE);
 	_stringLength->setVisible(
-		_entryData->_type == MacroActionVariable::Type::PAD ||
-		_entryData->_type == MacroActionVariable::Type::TRUNCATE);
-	_paddingCharSelection->setVisible(_entryData->_type ==
-					  MacroActionVariable::Type::PAD);
-	_caseType->setVisible(_entryData->_type ==
-			      MacroActionVariable::Type::CHANGE_CASE);
+		_entryData->_action == MacroActionVariable::Action::PAD ||
+		_entryData->_action == MacroActionVariable::Action::TRUNCATE);
+	_paddingCharSelection->setVisible(_entryData->_action ==
+					  MacroActionVariable::Action::PAD);
+	_caseType->setVisible(_entryData->_action ==
+			      MacroActionVariable::Action::CHANGE_CASE);
 	SetLayoutVisible(_randomLayout,
-			 _entryData->_type ==
-				 MacroActionVariable::Type::RANDOM_NUMBER);
+			 _entryData->_action ==
+				 MacroActionVariable::Action::RANDOM_NUMBER);
 
 	adjustSize();
 	updateGeometry();

lib/macro/macro-action-variable.hpp

@@ -28,8 +28,8 @@ public:
 	int GetSegmentIndexValue() const;
 	void ResolveVariablesToFixedValues();
 
-	enum class Type {
-		SET_FIXED_VALUE,
+	enum class Action {
+		SET_VALUE,
 		APPEND,
 		APPEND_VAR,
 		INCREMENT,
@@ -55,7 +55,7 @@ public:
 		RANDOM_NUMBER,
 	};
 
-	Type _type = Type::SET_FIXED_VALUE;
+	Action _action = Action::SET_VALUE;
 	std::weak_ptr<Variable> _variable;
 	std::weak_ptr<Variable> _variable2;
 	StringVariable _strValue = "";