handle import

Returns version and commit information

.github/workflows/build-project.yaml

@@ -249,6 +249,14 @@ jobs:
           name: ${{ steps.setup.outputs.pluginName }}-${{ steps.setup.outputs.pluginVersion }}-sources-${{ needs.check-event.outputs.commitHash }}
           path: ${{ github.workspace }}/release/${{ steps.setup.outputs.pluginName }}-*-source.*
 
+      - name: Rename artifacts for Ubuntu 24 🏷️
+        run: |
+          : Rename artifacts for Ubuntu 24 🏷️
+          for f in ${{ github.workspace }}/release/*-x86_64-linux-gnu.*; do
+            [ -e "${f}" ] || continue
+            mv "${f}" "${f/x86_64-linux-gnu/x86_64-ubuntu24.04-linux-gnu}"
+          done
+
       - name: Upload Artifacts 📡
         uses: actions/upload-artifact@v7
         with:
@@ -320,6 +328,14 @@ jobs:
           target: x86_64
           config: ${{ needs.check-event.outputs.config }}
 
+      - name: Rename artifacts for Ubuntu 26 🏷️
+        run: |
+          : Rename artifacts for Ubuntu 26 🏷️
+          for f in ${{ github.workspace }}/release/*-x86_64-linux-gnu.*; do
+            [ -e "${f}" ] || continue
+            mv "${f}" "${f/x86_64-linux-gnu/x86_64-ubuntu26.04-linux-gnu}"
+          done
+
       - name: Upload Artifacts 📡
         uses: actions/upload-artifact@v7
         with:

.github/workflows/push.yaml

@@ -78,6 +78,7 @@ jobs:
             'windows-x64;zip|exe'
             'macos-universal;tar.xz|pkg'
             'ubuntu-24.04-x86_64;tar.xz|deb|ddeb'
+            'ubuntu-26.04-x86_64;tar.xz|deb|ddeb'
             'sources;tar.xz'
           )
 

CMakeLists.txt

@@ -173,6 +173,8 @@ target_sources(
           lib/macro/macro-signals.hpp
           lib/macro/macro-tab.cpp
           lib/macro/macro-tree.cpp
+          lib/macro/macro-undo-redo.cpp
+          lib/macro/macro-undo-redo.hpp
           lib/macro/macro-tree.hpp
           lib/macro/macro-websocket-trigger.cpp
           lib/macro/macro.cpp

cmake/common/buildspec_common.cmake

@@ -191,14 +191,21 @@ function(_check_dependencies)
       foreach(i RANGE 1 ${MAX_DOWNLOAD_RETRIES})
         message(STATUS "Attempt ${i}/${MAX_DOWNLOAD_RETRIES} for ${url}")
 
-        file(
+        file(DOWNLOAD "${url}" "${dependencies_dir}/${file}"
-          DOWNLOAD "${url}" "${dependencies_dir}/${file}"
+             STATUS download_status)
-          STATUS download_status
-          EXPECTED_HASH SHA256=${hash})
 
         list(GET download_status 0 error_code)
         list(GET download_status 1 error_message)
 
+        if(error_code EQUAL 0)
+          file(SHA256 "${dependencies_dir}/${file}" actual_hash)
+          if(NOT actual_hash STREQUAL hash)
+            set(error_code 1)
+            set(error_message
+                "hash mismatch (expected ${hash}, got ${actual_hash})")
+          endif()
+        endif()
+
         if(error_code EQUAL 0)
           message(STATUS "Downloading ${url} - success on attempt ${i}")
           set(download_success TRUE)

data/locale/en-US.ini

@@ -198,6 +198,20 @@ AdvSceneSwitcher.macroTab.groupNameExists="The name \"%1\" is already used by a
 AdvSceneSwitcher.macroTab.removeSingleMacroPopup.text="Are you sure you want to remove \"%1\"?"
 AdvSceneSwitcher.macroTab.removeMultipleMacrosPopup.text="Are you sure you want to remove %1 macros/groups?"
 AdvSceneSwitcher.macroTab.removeGroupPopup.text="Are you sure you want to remove \"%1\" group and all its elements?"
+AdvSceneSwitcher.undo.renameMacro="Rename Macro '%1'"
+AdvSceneSwitcher.undo.modifyMacro="Modify Macro '%1'"
+AdvSceneSwitcher.undo.addMacro="Add Macro '%1'"
+AdvSceneSwitcher.undo.removeMacro="Remove Macro '%1'"
+AdvSceneSwitcher.undo.importMacros="Import Macros"
+AdvSceneSwitcher.undo.addSegment="Add %1 in '%2'"
+AdvSceneSwitcher.undo.removeSegment="Remove %1 in '%2'"
+AdvSceneSwitcher.undo.changeSegmentType="Change %1 Type in '%2'"
+AdvSceneSwitcher.undo.groupMacros="Group Macros '%1'"
+AdvSceneSwitcher.undo.ungroupMacros="Ungroup Macros '%1'"
+AdvSceneSwitcher.undo.removeMacroGroup="Remove Macro Group '%1'"
+AdvSceneSwitcher.undo.segment.action="Action"
+AdvSceneSwitcher.undo.segment.elseAction="Else Action"
+AdvSceneSwitcher.undo.segment.condition="Condition"
 AdvSceneSwitcher.macroTab.contextMenuAdd="Add"
 AdvSceneSwitcher.macroTab.copy="Duplicate Macro"
 AdvSceneSwitcher.macroTab.group="Group Selected Macros"
@@ -342,7 +356,9 @@ AdvSceneSwitcher.condition.audio.type.volume="Configured volume level"
 AdvSceneSwitcher.condition.audio.type.syncOffset="Sync offset"
 AdvSceneSwitcher.condition.audio.type.monitor="Audio monitoring"
 AdvSceneSwitcher.condition.audio.type.balance="Audio balance"
+AdvSceneSwitcher.condition.audio.type.track="Audio track"
 AdvSceneSwitcher.condition.audio.entry="{{checkType}}of{{audioSources}}is{{condition}}{{volume}}{{volumeDB}}{{percentDBToggle}}{{syncOffset}}{{monitorTypes}}"
+AdvSceneSwitcher.condition.audio.layout.track="{{audioSources}}is enabled on{{checkType}}{{track}}"
 AdvSceneSwitcher.condition.cursor="Cursor"
 AdvSceneSwitcher.condition.cursor.type.region="is in region"
 AdvSceneSwitcher.condition.cursor.type.moving="is moving"
@@ -904,9 +920,19 @@ AdvSceneSwitcher.condition.streamDeck.stopListen="Stop listening"
 AdvSceneSwitcher.condition.streamDeck.pluginDownload="<html><head/><body><p>The Stream Deck plugin can be found <a href=\"https://github.com/WarmUpTill/advanced-scene-switcher-streamdeck-plugin/releases\"><span style=\" text-decoration: underline; color:#268bd2;\">here on GitHub</span></a>.</p></body></html>"
 AdvSceneSwitcher.condition.gameCapture="Game capture"
 AdvSceneSwitcher.condition.gameCapture.entry="{{sources}}hooked a game."
-
 AdvSceneSwitcher.condition.screenshot="Screenshot"
 AdvSceneSwitcher.condition.screenshot.entry="A screenshot was taken"
+AdvSceneSwitcher.condition.nowPlaying="Now Playing"
+AdvSceneSwitcher.condition.nowPlaying.checkType.playbackState="Playback state"
+AdvSceneSwitcher.condition.nowPlaying.checkType.title="Title"
+AdvSceneSwitcher.condition.nowPlaying.checkType.artist="Artist"
+AdvSceneSwitcher.condition.nowPlaying.checkType.album="Album"
+AdvSceneSwitcher.condition.nowPlaying.checkType.appName="App name"
+AdvSceneSwitcher.condition.nowPlaying.playbackState.playing="Playing"
+AdvSceneSwitcher.condition.nowPlaying.playbackState.paused="Paused"
+AdvSceneSwitcher.condition.nowPlaying.playbackState.stopped="Stopped"
+AdvSceneSwitcher.condition.nowPlaying.playbackState.opening="Opening"
+AdvSceneSwitcher.condition.nowPlaying.playbackState.changing="Changing"
 AdvSceneSwitcher.condition.mqtt="MQTT"
 AdvSceneSwitcher.condition.mqtt.layout.match="Message was received from{{connection}} which matches{{regex}}:"
 AdvSceneSwitcher.condition.mqtt.layout.listen="Set message selection to incoming message:{{listenButton}}"
@@ -2364,6 +2390,7 @@ AdvSceneSwitcher.tempVar.audio.muted="Source muted"
 AdvSceneSwitcher.tempVar.audio.sync_offset="Source audio sync offset"
 AdvSceneSwitcher.tempVar.audio.monitor="Source audio monitor type"
 AdvSceneSwitcher.tempVar.audio.balance="Source audio balance"
+AdvSceneSwitcher.tempVar.audio.trackEnabled="Audio track enabled"
 
 AdvSceneSwitcher.tempVar.clipboard.mimeType.primary="Primary clipboard item MIME type"
 AdvSceneSwitcher.tempVar.clipboard.mimeType.primary.description="Highest priority MIME type of the current item stored in clipboard, if available."
@@ -2599,6 +2626,12 @@ AdvSceneSwitcher.tempVar.gameCapture.class.description="Window class of the appl
 AdvSceneSwitcher.tempVar.gameCapture.executable="Executable"
 AdvSceneSwitcher.tempVar.gameCapture.executable.description="Executable name of the application captured by the source."
 
+AdvSceneSwitcher.tempVar.nowPlaying.title="Title"
+AdvSceneSwitcher.tempVar.nowPlaying.artist="Artist"
+AdvSceneSwitcher.tempVar.nowPlaying.album="Album"
+AdvSceneSwitcher.tempVar.nowPlaying.appName="App name"
+AdvSceneSwitcher.tempVar.nowPlaying.playbackStatus="Playback status"
+
 AdvSceneSwitcher.tempVar.http.status="Status code"
 AdvSceneSwitcher.tempVar.http.error="Error"
 AdvSceneSwitcher.tempVar.http.error.description="Empty when no error occurred.\nOther possible values:\n\n * Could not establish connection\n * Failed to bind IP address\n * Failed to read connection\n * Failed to write connection\n * Maximum redirect count exceeded\n * Connection handling canceled\n * SSL connection failed\n * SSL certificate loading failed\n * SSL server verification failed\n * Unsupported HTTP multipart boundary characters\n * Compression failed\n * Connection timed out\n * Proxy connection failed\n * Unknown"

lib/macro/macro-action-edit.cpp

@@ -1,4 +1,5 @@
 #include "macro-action-edit.hpp"
+#include "macro-undo-redo.hpp"
 #include "advanced-scene-switcher.hpp"
 #include "macro-helpers.hpp"
 #include "macro-settings.hpp"
@@ -111,9 +112,32 @@ void MacroActionEdit::ActionSelectionChanged(const QString &text)
 		return;
 	}
 
+	Macro *const parentMacro =
+		(*_entryData)->GetMacro()->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	}
+
+	const std::string oldId = (*_entryData)->GetId();
+	OBSDataAutoRelease oldData = obs_data_create();
+	(*_entryData)->Save(oldData);
+
 	HeaderInfoChanged("");
 	auto idx = _entryData->get()->GetIndex();
 	auto macro = _entryData->get()->GetMacro();
+
+	// Determine whether this is an action or else-action before resetting.
+	const auto *rawPtr = (*_entryData).get();
+	const auto &elseActions = macro->ElseActions();
+	const bool isElse = std::any_of(elseActions.begin(), elseActions.end(),
+					[rawPtr](const auto &a) {
+						return a.get() == rawPtr;
+					});
+	const auto segmentType = isElse ? MacroEdit::SegmentType::ELSE_ACTION
+					: MacroEdit::SegmentType::ACTION;
+
 	{
 		auto lock = LockContext();
 		_entryData->reset();
@@ -122,6 +146,16 @@ void MacroActionEdit::ActionSelectionChanged(const QString &text)
 		(*_entryData)->PostLoad();
 		RunAndClearPostLoadSteps();
 	}
+
+	OBSDataAutoRelease newData = obs_data_create();
+	(*_entryData)->Save(newData);
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	} else {
+		RegisterSegmentTypeChangeUndoRedo(macro, segmentType, idx,
+						  oldId, oldData, 0, id,
+						  newData, 0);
+	}
 	auto widget = MacroActionFactory::CreateWidget(id, this, *_entryData);
 	QWidget::connect(widget, SIGNAL(HeaderInfoChanged(const QString &)),
 			 this, SLOT(HeaderInfoChanged(const QString &)));

lib/macro/macro-action-loop.cpp

@@ -83,6 +83,7 @@ bool MacroActionLoop::PostLoad()
 	MacroAction::PostLoad();
 	_loopMacro->PostLoad();
 	_loopMacro->SetActionTriggerMode(Macro::ActionTriggerMode::ALWAYS);
+	_loopMacro->SetNestedParentMacro(GetMacro());
 	return true;
 }
 

lib/macro/macro-action-macro.cpp

@@ -281,6 +281,7 @@ bool MacroActionMacro::PostLoad()
 	MacroAction::PostLoad();
 	_runOptions.macro.PostLoad();
 	_nestedMacro->PostLoad();
+	_nestedMacro->SetNestedParentMacro(GetMacro());
 	return true;
 }
 

lib/macro/macro-condition-edit.cpp

@@ -1,4 +1,5 @@
 #include "macro-condition-edit.hpp"
+#include "macro-undo-redo.hpp"
 
 #include "advanced-scene-switcher.hpp"
 #include "condition-logic.hpp"
@@ -250,6 +251,19 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 		return;
 	}
 
+	Macro *const parentMacro =
+		(*_entryData)->GetMacro()->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	}
+
+	const std::string oldId = (*_entryData)->GetId();
+	const int oldLogic = (int)(*_entryData)->GetLogicType();
+	OBSDataAutoRelease oldData = obs_data_create();
+	(*_entryData)->Save(oldData);
+
 	auto temp = DurationModifier();
 	_dur->SetValue(temp);
 	HeaderInfoChanged("");
@@ -267,6 +281,17 @@ void MacroConditionEdit::ConditionSelectionChanged(const QString &text)
 		(*_entryData)->PostLoad();
 		RunAndClearPostLoadSteps();
 	}
+
+	OBSDataAutoRelease newData = obs_data_create();
+	(*_entryData)->Save(newData);
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	} else {
+		RegisterSegmentTypeChangeUndoRedo(
+			macro, MacroEdit::SegmentType::CONDITION, idx, oldId,
+			oldData, oldLogic, id, newData,
+			(int)(*_entryData)->GetLogicType());
+	}
 	auto widget =
 		MacroConditionFactory::CreateWidget(id, this, *_entryData);
 	QWidget::connect(widget, SIGNAL(HeaderInfoChanged(const QString &)),

lib/macro/macro-edit.cpp

@@ -1,6 +1,7 @@
 #include "macro-edit.hpp"
 
 #include "condition-logic.hpp"
+#include "macro-undo-redo.hpp"
 #include "cursor-shape-changer.hpp"
 #include "macro-action-edit.hpp"
 #include "macro-action-macro.hpp"
@@ -257,6 +258,92 @@ std::shared_ptr<Macro> MacroEdit::GetMacro() const
 	return _currentMacro;
 }
 
+void MacroEdit::InsertSegmentWidget(SegmentType type, int idx)
+{
+	auto macro = _currentMacro;
+	if (!macro) {
+		return;
+	}
+
+	switch (type) {
+	case SegmentType::ACTION: {
+		if (idx < 0 || idx > (int)macro->Actions().size()) {
+			break;
+		}
+		ui->actionsList->Insert(
+			idx, new MacroActionEdit(this, &macro->Actions()[idx]));
+		SetActionData(*macro);
+		ui->actionsList->SetHelpMsgVisible(false);
+		break;
+	}
+	case SegmentType::ELSE_ACTION: {
+		if (idx < 0 || idx > (int)macro->ElseActions().size()) {
+			break;
+		}
+		ui->elseActionsList->Insert(
+			idx,
+			new MacroActionEdit(this, &macro->ElseActions()[idx]));
+		SetElseActionData(*macro);
+		ui->elseActionsList->SetHelpMsgVisible(false);
+		break;
+	}
+	case SegmentType::CONDITION: {
+		if (idx < 0 || idx > (int)macro->Conditions().size()) {
+			break;
+		}
+		ui->conditionsList->Insert(
+			idx,
+			new MacroConditionEdit(this, &macro->Conditions()[idx],
+					       idx == 0));
+		if (idx == 0 && macro->Conditions().size() > 1) {
+			static_cast<MacroConditionEdit *>(
+				ui->conditionsList->WidgetAt(1))
+				->SetRootNode(false);
+		}
+		SetConditionData(*macro);
+		ui->conditionsList->SetHelpMsgVisible(false);
+		break;
+	}
+	}
+}
+
+void MacroEdit::RemoveSegmentWidget(SegmentType type, int idx)
+{
+	auto macro = _currentMacro;
+	if (!macro) {
+		return;
+	}
+
+	switch (type) {
+	case SegmentType::ACTION:
+		if (idx >= 0 &&
+		    idx < ui->actionsList->ContentLayout()->count()) {
+			ui->actionsList->Remove(idx);
+			SetActionData(*macro);
+		}
+		break;
+	case SegmentType::ELSE_ACTION:
+		if (idx >= 0 &&
+		    idx < ui->elseActionsList->ContentLayout()->count()) {
+			ui->elseActionsList->Remove(idx);
+			SetElseActionData(*macro);
+		}
+		break;
+	case SegmentType::CONDITION:
+		if (idx >= 0 &&
+		    idx < ui->conditionsList->ContentLayout()->count()) {
+			ui->conditionsList->Remove(idx);
+			if (idx == 0 && !macro->Conditions().empty()) {
+				static_cast<MacroConditionEdit *>(
+					ui->conditionsList->WidgetAt(0))
+					->SetRootNode(true);
+			}
+			SetConditionData(*macro);
+		}
+		break;
+	}
+}
+
 void MacroEdit::ClearSegmentWidgetCacheFor(Macro *macro) const
 {
 	ui->conditionsList->ClearWidgetsFromCacheFor(macro);
@@ -295,7 +382,7 @@ isValidMacroSegmentIdx(const std::deque<std::shared_ptr<MacroSegment>> &list,
 	return (idx > 0 || (unsigned)idx < list.size());
 }
 
-void MacroEdit::SetupMacroSegmentSelection(MacroSection type, int idx)
+void MacroEdit::SetupMacroSegmentSelection(SegmentType type, int idx)
 {
 	auto macro = _currentMacro;
 	if (!macro) {
@@ -308,7 +395,7 @@ void MacroEdit::SetupMacroSegmentSelection(MacroSection type, int idx)
 	std::deque<std::shared_ptr<MacroSegment>> segments;
 
 	switch (type) {
-	case MacroEdit::MacroSection::CONDITIONS:
+	case MacroEdit::SegmentType::CONDITION:
 		setList = ui->conditionsList;
 		setIdx = &currentConditionIdx;
 		segments = {macro->Conditions().begin(),
@@ -319,7 +406,7 @@ void MacroEdit::SetupMacroSegmentSelection(MacroSection type, int idx)
 		resetIdx1 = &currentActionIdx;
 		resetIdx2 = &currentElseActionIdx;
 		break;
-	case MacroEdit::MacroSection::ACTIONS:
+	case MacroEdit::SegmentType::ACTION:
 		setList = ui->actionsList;
 		setIdx = &currentActionIdx;
 		segments = {macro->Actions().begin(), macro->Actions().end()};
@@ -329,7 +416,7 @@ void MacroEdit::SetupMacroSegmentSelection(MacroSection type, int idx)
 		resetIdx1 = &currentConditionIdx;
 		resetIdx2 = &currentElseActionIdx;
 		break;
-	case MacroEdit::MacroSection::ELSE_ACTIONS:
+	case MacroEdit::SegmentType::ELSE_ACTION:
 		setList = ui->elseActionsList;
 		setIdx = &currentElseActionIdx;
 		segments = {macro->ElseActions().begin(),
@@ -965,7 +1052,7 @@ void MacroEdit::UpMacroSegmentHotkey()
 	int conditionSize = macro->Conditions().size();
 
 	if (currentActionIdx == -1 && currentConditionIdx == -1) {
-		if (lastInteracted == MacroSection::CONDITIONS) {
+		if (lastInteracted == SegmentType::CONDITION) {
 			if (conditionSize == 0) {
 				MacroActionSelectionChanged(0);
 			} else {
@@ -1021,7 +1108,7 @@ void MacroEdit::DownMacroSegmentHotkey()
 	int conditionSize = macro->Conditions().size();
 
 	if (currentActionIdx == -1 && currentConditionIdx == -1) {
-		if (lastInteracted == MacroSection::CONDITIONS) {
+		if (lastInteracted == SegmentType::CONDITION) {
 			if (conditionSize == 0) {
 				MacroActionSelectionChanged(0);
 			} else {
@@ -1084,6 +1171,13 @@ void MacroEdit::AddMacroAction(Macro *macro, int idx, const std::string &id,
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	}
+
 	{
 		auto lock = LockContext();
 		macro->Actions().emplace(macro->Actions().begin() + idx,
@@ -1098,6 +1192,11 @@ void MacroEdit::AddMacroAction(Macro *macro, int idx, const std::string &id,
 			idx, new MacroActionEdit(this, &macro->Actions()[idx]));
 		SetActionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	} else {
+		RegisterSegmentAddUndoRedo(macro, SegmentType::ACTION, idx);
+	}
 	HighlightAction(idx);
 	ui->actionsList->SetHelpMsgVisible(false);
 	emit(MacroSegmentOrderChanged());
@@ -1163,6 +1262,24 @@ void MacroEdit::RemoveMacroAction(int idx)
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	} else {
+		OBSDataAutoRelease segData = obs_data_create();
+		std::string segId;
+		{
+			auto lock = LockContext();
+			macro->Actions().at(idx)->Save(segData);
+			segId = macro->Actions().at(idx)->GetId();
+		}
+		RegisterSegmentRemoveUndoRedo(macro.get(), SegmentType::ACTION,
+					      idx, segId, segData,
+					      (int)Logic::Type::ROOT_NONE);
+	}
+
 	{
 		auto lock = LockContext();
 		ui->actionsList->Remove(idx);
@@ -1172,8 +1289,11 @@ void MacroEdit::RemoveMacroAction(int idx)
 		macro->UpdateActionIndices();
 		SetActionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	}
 	MacroActionSelectionChanged(-1);
-	lastInteracted = MacroSection::ACTIONS;
+	lastInteracted = SegmentType::ACTION;
 	emit(MacroSegmentOrderChanged());
 }
 
@@ -1353,7 +1473,7 @@ void MacroEdit::MoveMacroActionDown(int idx)
 
 void MacroEdit::MacroElseActionSelectionChanged(int idx)
 {
-	SetupMacroSegmentSelection(MacroSection::ELSE_ACTIONS, idx);
+	SetupMacroSegmentSelection(SegmentType::ELSE_ACTION, idx);
 }
 
 void MacroEdit::MacroElseActionReorder(int to, int from)
@@ -1390,6 +1510,13 @@ void MacroEdit::AddMacroElseAction(Macro *macro, int idx, const std::string &id,
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	}
+
 	{
 		auto lock = LockContext();
 		macro->ElseActions().emplace(macro->ElseActions().begin() + idx,
@@ -1406,6 +1533,12 @@ void MacroEdit::AddMacroElseAction(Macro *macro, int idx, const std::string &id,
 			new MacroActionEdit(this, &macro->ElseActions()[idx]));
 		SetElseActionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	} else {
+		RegisterSegmentAddUndoRedo(macro, SegmentType::ELSE_ACTION,
+					   idx);
+	}
 	HighlightElseAction(idx);
 	ui->elseActionsList->SetHelpMsgVisible(false);
 	emit(MacroSegmentOrderChanged());
@@ -1455,6 +1588,25 @@ void MacroEdit::RemoveMacroElseAction(int idx)
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	} else {
+		OBSDataAutoRelease segData = obs_data_create();
+		std::string segId;
+		{
+			auto lock = LockContext();
+			macro->ElseActions().at(idx)->Save(segData);
+			segId = macro->ElseActions().at(idx)->GetId();
+		}
+		RegisterSegmentRemoveUndoRedo(macro.get(),
+					      SegmentType::ELSE_ACTION, idx,
+					      segId, segData,
+					      (int)Logic::Type::ROOT_NONE);
+	}
+
 	{
 		auto lock = LockContext();
 		ui->elseActionsList->Remove(idx);
@@ -1464,8 +1616,11 @@ void MacroEdit::RemoveMacroElseAction(int idx)
 		macro->UpdateElseActionIndices();
 		SetElseActionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	}
 	MacroElseActionSelectionChanged(-1);
-	lastInteracted = MacroSection::ELSE_ACTIONS;
+	lastInteracted = SegmentType::ELSE_ACTION;
 	emit(MacroSegmentOrderChanged());
 }
 
@@ -1526,7 +1681,7 @@ void MacroEdit::MoveMacroElseActionDown(int idx)
 
 void MacroEdit::MacroActionSelectionChanged(int idx)
 {
-	SetupMacroSegmentSelection(MacroSection::ACTIONS, idx);
+	SetupMacroSegmentSelection(SegmentType::ACTION, idx);
 }
 
 void MacroEdit::MacroActionReorder(int to, int from)
@@ -1599,6 +1754,13 @@ void MacroEdit::AddMacroCondition(Macro *macro, int idx, const std::string &id,
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	}
+
 	{
 		auto lock = LockContext();
 		auto cond = macro->Conditions().emplace(
@@ -1617,6 +1779,11 @@ void MacroEdit::AddMacroCondition(Macro *macro, int idx, const std::string &id,
 					       idx == 0));
 		SetConditionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	} else {
+		RegisterSegmentAddUndoRedo(macro, SegmentType::CONDITION, idx);
+	}
 	HighlightCondition(idx);
 	ui->conditionsList->SetHelpMsgVisible(false);
 	emit(MacroSegmentOrderChanged());
@@ -1652,6 +1819,26 @@ void MacroEdit::RemoveMacroCondition(int idx)
 		return;
 	}
 
+	Macro *const parentMacro = macro->GetNestedParentMacro();
+	OBSDataAutoRelease parentBeforeData;
+	if (parentMacro) {
+		parentBeforeData = obs_data_create();
+		parentMacro->Save(parentBeforeData);
+	} else {
+		OBSDataAutoRelease segData = obs_data_create();
+		std::string segId;
+		int logic;
+		{
+			auto lock = LockContext();
+			macro->Conditions().at(idx)->Save(segData);
+			segId = macro->Conditions().at(idx)->GetId();
+			logic = (int)macro->Conditions().at(idx)->GetLogicType();
+		}
+		RegisterSegmentRemoveUndoRedo(macro.get(),
+					      SegmentType::CONDITION, idx,
+					      segId, segData, logic);
+	}
+
 	{
 		auto lock = LockContext();
 		ui->conditionsList->Remove(idx);
@@ -1666,8 +1853,11 @@ void MacroEdit::RemoveMacroCondition(int idx)
 		}
 		SetConditionData(*macro);
 	}
+	if (parentMacro) {
+		RegisterMacroModifyUndoRedo(parentMacro, parentBeforeData);
+	}
 	MacroConditionSelectionChanged(-1);
-	lastInteracted = MacroSection::CONDITIONS;
+	lastInteracted = SegmentType::CONDITION;
 	emit(MacroSegmentOrderChanged());
 }
 
@@ -1792,7 +1982,7 @@ void MacroEdit::MoveMacroConditionDown(int idx)
 
 void MacroEdit::MacroConditionSelectionChanged(int idx)
 {
-	SetupMacroSegmentSelection(MacroSection::CONDITIONS, idx);
+	SetupMacroSegmentSelection(SegmentType::CONDITION, idx);
 }
 
 void MacroEdit::MacroConditionReorder(int to, int from)

lib/macro/macro-edit.hpp

@@ -12,11 +12,15 @@ class MacroEdit : public QWidget {
 	Q_OBJECT
 
 public:
+	enum class SegmentType { CONDITION, ACTION, ELSE_ACTION };
+
 	MacroEdit(QWidget *parent, QStringList helpMsg = {});
 	void SetMacro(const std::shared_ptr<Macro> &);
 	std::shared_ptr<Macro> GetMacro() const;
 	void ClearSegmentWidgetCacheFor(Macro *) const;
 	void SetControlsDisabled(bool disable) const;
+	void InsertSegmentWidget(SegmentType type, int idx);
+	void RemoveSegmentWidget(SegmentType type, int idx);
 	void HighlightAction(int idx, QColor color = QColor(Qt::green)) const;
 	void HighlightElseAction(int idx,
 				 QColor color = QColor(Qt::green)) const;
@@ -112,14 +116,12 @@ protected:
 	bool eventFilter(QObject *obj, QEvent *event) override;
 
 private:
-	enum class MacroSection { CONDITIONS, ACTIONS, ELSE_ACTIONS };
-
 	void PopulateMacroActions(Macro &m, uint32_t afterIdx = 0);
 	void PopulateMacroElseActions(Macro &m, uint32_t afterIdx = 0);
 	void PopulateMacroConditions(Macro &m, uint32_t afterIdx = 0);
 	void ScrollAndFocusNewSegment(MacroSegmentList *list, int newIdx,
 				      int *currentIdx);
-	void SetupMacroSegmentSelection(MacroSection type, int idx);
+	void SetupMacroSegmentSelection(SegmentType type, int idx);
 	void
 	SetupContextMenu(const QPoint &pos,
 			 const std::function<void(MacroEdit *, int)> &remove,
@@ -131,7 +133,7 @@ private:
 	void RunSegmentHighlightChecks();
 	bool ElseSectionIsVisible() const;
 
-	MacroSection lastInteracted = MacroSection::CONDITIONS;
+	SegmentType lastInteracted = SegmentType::CONDITION;
 	int currentConditionIdx = -1;
 	int currentActionIdx = -1;
 	int currentElseActionIdx = -1;

lib/macro/macro-segment-list.cpp

@@ -201,6 +201,8 @@ bool MacroSegmentList::PopulateWidgetsFromCache(const Macro *macro)
 		_contentLayout->addWidget(widget);
 		widget->show();
 	}
+	// Widgets are now owned by the layout again, so the cache entry is stale.
+	_widgetCache.erase(it);
 
 	adjustSize();
 	updateGeometry();
@@ -463,7 +465,17 @@ void MacroSegmentList::SetupVisibleMacroSegmentWidgets()
 
 	const auto viewportRect = viewport()->rect();
 
-	for (auto segment : widget()->findChildren<MacroSegmentEdit *>()) {
+	for (int i = 0; i < _contentLayout->count(); ++i) {
+		auto item = _contentLayout->itemAt(i);
+		if (!item) {
+			continue;
+		}
+
+		auto segment = dynamic_cast<MacroSegmentEdit *>(item->widget());
+		if (!segment) {
+			continue;
+		}
+
 		const auto pos = segment->mapTo(viewport(), QPoint(0, 0));
 		const QRect rect(pos, segment->size());
 		if (!viewportRect.intersects(rect)) {

lib/macro/macro-tab.cpp

@@ -7,6 +7,7 @@
 #include "macro-settings.hpp"
 #include "macro-signals.hpp"
 #include "macro-tree.hpp"
+#include "macro-undo-redo.hpp"
 #include "macro.hpp"
 #include "math-helpers.hpp"
 #include "name-dialog.hpp"
@@ -122,6 +123,7 @@ void AdvSceneSwitcher::on_macroAdd_clicked()
 		ui->macros->Add(newMacro);
 		MacroSignalManager::Instance()->Add(
 			QString::fromStdString(name));
+		RegisterMacroAddUndoRedo(name);
 		return;
 	}
 
@@ -131,6 +133,7 @@ void AdvSceneSwitcher::on_macroAdd_clicked()
 		ui->macros->AddToGroup(newMacro, selectedMacro);
 		MacroSignalManager::Instance()->Add(
 			QString::fromStdString(name));
+		RegisterMacroAddUndoRedo(name);
 		return;
 	}
 
@@ -139,12 +142,14 @@ void AdvSceneSwitcher::on_macroAdd_clicked()
 		ui->macros->Add(newMacro, selectedMacro);
 		MacroSignalManager::Instance()->Add(
 			QString::fromStdString(name));
+		RegisterMacroAddUndoRedo(name);
 		return;
 	}
 
 	Macro::PrepareMoveToGroup(selectedMacroGroup, newMacro);
 	ui->macros->Add(newMacro, selectedMacro);
 	MacroSignalManager::Instance()->Add(QString::fromStdString(name));
+	RegisterMacroAddUndoRedo(name);
 }
 
 static void addGroupSubitems(std::vector<std::shared_ptr<Macro>> &macros,
@@ -185,6 +190,12 @@ void AdvSceneSwitcher::RemoveMacro(std::shared_ptr<Macro> &macro)
 		}
 	}
 
+	if (macro->IsGroup()) {
+		RegisterGroupDeleteUndoRedo(macro.get());
+	} else {
+		RegisterMacroRemoveUndoRedo(macro.get());
+	}
+
 	if (macro->IsGroup()) {
 		std::vector<std::shared_ptr<Macro>> macros = {macro};
 		addGroupSubitems(macros, macro);
@@ -241,13 +252,16 @@ void AdvSceneSwitcher::RemoveSelectedMacros()
 void AdvSceneSwitcher::RenameMacro(std::shared_ptr<Macro> &macro,
 				   const QString &name)
 {
-	auto oldName = QString::fromStdString(macro->Name());
+	const std::string oldName = macro->Name();
+	const std::string newName = name.toStdString();
 	{
 		auto lock = LockContext();
-		macro->SetName(name.toStdString());
+		macro->SetName(newName);
 	}
 
-	MacroSignalManager::Instance()->Rename(oldName, name);
+	RegisterMacroRenameUndoRedo(oldName, newName);
+	MacroSignalManager::Instance()->Rename(QString::fromStdString(oldName),
+					       name);
 }
 
 void AdvSceneSwitcher::on_macroRemove_clicked()
@@ -443,6 +457,7 @@ void AdvSceneSwitcher::ImportMacros()
 	ui->macros->Reset(GetTopLevelMacros(),
 			  GetGlobalMacroSettings()._highlightExecuted);
 	disableAddButtonHighlight();
+	RegisterMacrosImportUndoRedo(importedMacros);
 }
 
 void AdvSceneSwitcher::on_macroName_editingFinished()
@@ -814,6 +829,7 @@ void AdvSceneSwitcher::CopyMacro()
 	ui->macros->Add(newMacro, macro);
 	disableAddButtonHighlight();
 	MacroSignalManager::Instance()->Add(QString::fromStdString(name));
+	RegisterMacroAddUndoRedo(name);
 }
 
 void AdvSceneSwitcher::PauseSelectedMacros()

lib/macro/macro-tree.cpp

@@ -1,4 +1,5 @@
 #include "macro-tree.hpp"
+#include "macro-undo-redo.hpp"
 
 #include "macro-helpers.hpp"
 #include "macro-search.hpp"
@@ -824,6 +825,8 @@ void MacroTreeModel::GroupSelectedItems(QModelIndexList &indices)
 
 	Reset(_macros);
 	assert(IsInValidState());
+
+	RegisterGroupCreateUndoRedo(name.toStdString());
 }
 
 void MacroTreeModel::UngroupSelectedGroups(QModelIndexList &indices)
@@ -837,6 +840,7 @@ void MacroTreeModel::UngroupSelectedGroups(QModelIndexList &indices)
 		std::shared_ptr<Macro> item = _macros[ModelIndexToMacroIndex(
 			indices[i].row(), _macros)];
 		if (item->IsGroup()) {
+			RegisterGroupRemoveUndoRedo(item->Name());
 			Macro::RemoveGroup(item);
 		}
 	}

lib/macro/macro-undo-redo.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "macro-edit.hpp"
+
+#include <obs-data.h>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace advss {
+
+class Macro;
+
+void RegisterMacroAddUndoRedo(const std::string &macroName);
+bool RegisterMacroRemoveUndoRedo(Macro *macro);
+void RegisterSegmentAddUndoRedo(Macro *macro, MacroEdit::SegmentType type,
+				int index);
+void RegisterSegmentTypeChangeUndoRedo(Macro *macro,
+				       MacroEdit::SegmentType type, int index,
+				       const std::string &oldId,
+				       obs_data_t *oldData, int oldLogic,
+				       const std::string &newId,
+				       obs_data_t *newData, int newLogic);
+void RegisterSegmentRemoveUndoRedo(Macro *macro, MacroEdit::SegmentType type,
+				   int index, const std::string &segmentId,
+				   obs_data_t *segmentData, int logic);
+void RegisterMacroRenameUndoRedo(const std::string &oldName,
+				 const std::string &newName);
+void RegisterGroupCreateUndoRedo(const std::string &groupName);
+void RegisterGroupRemoveUndoRedo(const std::string &groupName);
+void RegisterGroupDeleteUndoRedo(Macro *macro);
+void RegisterMacroModifyUndoRedo(Macro *parentMacro, obs_data_t *beforeData);
+void RegisterMacrosImportUndoRedo(
+	const std::vector<std::shared_ptr<Macro>> &importedMacros);
+
+} // namespace advss

lib/macro/macro.hpp

@@ -130,6 +130,13 @@ public:
 	void SetParent(std::shared_ptr<Macro> m) { _parent = m; }
 	std::shared_ptr<Macro> Parent() const;
 
+	// For nested macros embedded in actions (e.g. loop, nested-macro action)
+	void SetNestedParentMacro(Macro *parent)
+	{
+		_nestedParentMacro = parent;
+	}
+	Macro *GetNestedParentMacro() const { return _nestedParentMacro; }
+
 	// Saving and loading
 	bool Save(obs_data_t *obj, bool saveForCopy = false) const;
 	bool Load(obs_data_t *obj);
@@ -187,6 +194,7 @@ private:
 	std::deque<std::shared_ptr<MacroAction>> _elseActions;
 
 	std::weak_ptr<Macro> _parent;
+	Macro *_nestedParentMacro = nullptr;
 	uint32_t _groupSize = 0;
 	bool _isGroup = false;
 	bool _isCollapsed = false;

lib/utils/websocket-api.cpp

@@ -1,6 +1,7 @@
 #include "websocket-api.hpp"
 #include "obs-websocket-api.h"
 #include "plugin-state-helpers.hpp"
+#include "version.h"
 
 // Must be after "obs-websocket-api.h" to avoid logging function conflict
 #include "log-helper.hpp"
@@ -15,6 +16,7 @@ static constexpr char VendorName[] = "AdvancedSceneSwitcher";
 static constexpr char VendorRequestStart[] = "AdvancedSceneSwitcherStart";
 static constexpr char VendorRequestStop[] = "AdvancedSceneSwitcherStop";
 static constexpr char VendorRequestStatus[] = "IsAdvancedSceneSwitcherRunning";
+static constexpr char VendorRequestVersion[] = "AdvancedSceneSwitcherVersion";
 static obs_websocket_vendor vendor;
 
 static void registerWebsocketVendor();
@@ -82,6 +84,12 @@ static void registerWebsocketVendor()
 			obs_data_set_bool(response, "isRunning",
 					  PluginIsRunning());
 		});
+	registerWebsocketVendorRequest(
+		VendorRequestVersion,
+		[](obs_data_t *, obs_data_t *response, void *) {
+			obs_data_set_string(response, "version", g_GIT_TAG);
+			obs_data_set_string(response, "commit", g_GIT_SHA1);
+		});
 }
 
 const char *GetWebsocketVendorName()

plugins/CMakeLists.txt

@@ -42,6 +42,7 @@ add_plugin(twitch)
 add_plugin(usb)
 add_plugin(video)
 add_plugin(speech)
+add_plugin(now-playing)
 
 # ---------------------------------------------------------------------------- #
 

plugins/base/macro-action-scene-collection.cpp

@@ -1,7 +1,9 @@
 #include "macro-action-scene-collection.hpp"
+
 #include "layout-helpers.hpp"
 #include "plugin-state-helpers.hpp"
 #include "selection-helpers.hpp"
+#include "ui-helpers.hpp"
 
 #include <obs-frontend-api.h>
 
@@ -15,6 +17,20 @@ bool MacroActionSceneCollection::_registered = MacroActionFactory::Register(
 	 MacroActionSceneCollectionEdit::Create,
 	 "AdvSceneSwitcher.action.sceneCollection"});
 
+template<typename F> void QueueUITaskLambda(F &&func)
+{
+	using FnType = std::decay_t<F>;
+	auto *heapFunc = new FnType(std::forward<F>(func));
+
+	QueueUITask(
+		[](void *param) {
+			std::unique_ptr<FnType> fn(
+				static_cast<FnType *>(param));
+			(*fn)();
+		},
+		heapFunc);
+}
+
 bool MacroActionSceneCollection::PerformAction()
 {
 	// Changing the scene collection will also reload the settings of the
@@ -23,7 +39,13 @@ bool MacroActionSceneCollection::PerformAction()
 	if (SettingsWindowIsOpened()) {
 		return false;
 	}
-	obs_frontend_set_current_scene_collection(_sceneCollection.c_str());
+
+	const auto collectionName = _sceneCollection;
+	QueueUITaskLambda([collectionName]() {
+		obs_frontend_set_current_scene_collection(
+			collectionName.c_str());
+	});
+
 	// It does not make sense to continue as the current settings will be
 	// invalid after switching scene collection.
 	return false;

plugins/base/macro-condition-audio.cpp

@@ -25,6 +25,8 @@ const static std::map<MacroConditionAudio::Type, std::string> checkTypes = {
 	 "AdvSceneSwitcher.condition.audio.type.monitor"},
 	{MacroConditionAudio::Type::BALANCE,
 	 "AdvSceneSwitcher.condition.audio.type.balance"},
+	{MacroConditionAudio::Type::TRACK,
+	 "AdvSceneSwitcher.condition.audio.type.track"},
 };
 
 const static std::map<MacroConditionAudio::OutputCondition, std::string>
@@ -245,6 +247,20 @@ bool MacroConditionAudio::CheckBalance()
 	return ret && source;
 }
 
+bool MacroConditionAudio::CheckTrack()
+{
+	if (!_audioSource.GetSource()) {
+		return false;
+	}
+
+	OBSSourceAutoRelease source =
+		obs_weak_source_get_source(_audioSource.GetSource());
+	uint32_t mixers = obs_source_get_audio_mixers(source);
+	bool enabled = (mixers >> (uint32_t)(_track - 1)) & 1u;
+	SetTempVarValue("track_enabled", enabled ? "true" : "false");
+	return enabled && source;
+}
+
 bool MacroConditionAudio::CheckCondition()
 {
 	bool ret = false;
@@ -264,6 +280,9 @@ bool MacroConditionAudio::CheckCondition()
 	case Type::BALANCE:
 		ret = CheckBalance();
 		break;
+	case Type::TRACK:
+		ret = CheckTrack();
+		break;
 	}
 
 	if (GetVariableValue().empty()) {
@@ -281,6 +300,7 @@ bool MacroConditionAudio::Save(obs_data_t *obj) const
 	_volumePercent.Save(obj, "volume");
 	_syncOffset.Save(obj, "syncOffset");
 	_balance.Save(obj, "balance");
+	_track.Save(obj, "track");
 	obs_data_set_int(obj, "checkType", static_cast<int>(_checkType));
 	obs_data_set_int(obj, "outputCondition",
 			 static_cast<int>(_outputCondition));
@@ -346,6 +366,7 @@ bool MacroConditionAudio::Load(obs_data_t *obj)
 		_useDb = obs_data_get_bool(obj, "useDb");
 		_volumeDB.Load(obj, "volumeDB");
 	}
+	_track.Load(obj, "track");
 	return true;
 }
 
@@ -421,6 +442,12 @@ void MacroConditionAudio::SetupTempVars()
 			   obs_module_text(
 				   "AdvSceneSwitcher.tempVar.audio.balance"));
 		break;
+	case Type::TRACK:
+		AddTempvar(
+			"track_enabled",
+			obs_module_text(
+				"AdvSceneSwitcher.tempVar.audio.trackEnabled"));
+		break;
 	default:
 		break;
 	}
@@ -468,6 +495,7 @@ static QStringList getAudioSourcesList()
 MacroConditionAudioEdit::MacroConditionAudioEdit(
 	QWidget *parent, std::shared_ptr<MacroConditionAudio> entryData)
 	: QWidget(parent),
+	  _layout(new QHBoxLayout),
 	  _checkTypes(new QComboBox()),
 	  _sources(new SourceSelectionWidget(this, getAudioSourcesList, true)),
 	  _condition(new QComboBox()),
@@ -476,7 +504,8 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 	  _percentDBToggle(new QPushButton),
 	  _syncOffset(new VariableSpinBox()),
 	  _monitorTypes(new QComboBox),
-	  _balance(new SliderSpinBox(0., 1., ""))
+	  _balance(new SliderSpinBox(0., 1., "")),
+	  _track(new VariableSpinBox())
 {
 	_volumePercent->setSuffix("%");
 	_volumePercent->setMaximum(100);
@@ -491,6 +520,9 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 	_syncOffset->setMaximum(20000);
 	_syncOffset->setSuffix("ms");
 
+	_track->setMinimum(1);
+	_track->setMaximum(32);
+
 	QWidget::connect(_checkTypes, SIGNAL(currentIndexChanged(int)), this,
 			 SLOT(CheckTypeChanged(int)));
 	QWidget::connect(
@@ -519,27 +551,16 @@ MacroConditionAudioEdit::MacroConditionAudioEdit(
 		this, SLOT(VolumeDBChanged(const NumberVariable<double> &)));
 	QWidget::connect(_percentDBToggle, SIGNAL(clicked()), this,
 			 SLOT(PercentDBClicked()));
+	QWidget::connect(
+		_track,
+		SIGNAL(NumberVariableChanged(const NumberVariable<int> &)),
+		this, SLOT(TrackChanged(const NumberVariable<int> &)));
 
 	populateCheckTypes(_checkTypes);
 	PopulateMonitorTypeSelection(_monitorTypes);
 
-	QHBoxLayout *switchLayout = new QHBoxLayout;
-	std::unordered_map<std::string, QWidget *> widgetPlaceholders = {
-		{"{{checkType}}", _checkTypes},
-		{"{{audioSources}}", _sources},
-		{"{{volume}}", _volumePercent},
-		{"{{syncOffset}}", _syncOffset},
-		{"{{monitorTypes}}", _monitorTypes},
-		{"{{balance}}", _balance},
-		{"{{condition}}", _condition},
-		{"{{volumeDB}}", _volumeDB},
-		{"{{percentDBToggle}}", _percentDBToggle},
-	};
-	PlaceWidgets(obs_module_text("AdvSceneSwitcher.condition.audio.entry"),
-		     switchLayout, widgetPlaceholders);
-
 	QVBoxLayout *mainLayout = new QVBoxLayout;
-	mainLayout->addLayout(switchLayout);
+	mainLayout->addLayout(_layout);
 	mainLayout->addWidget(_balance);
 	setLayout(mainLayout);
 
@@ -608,6 +629,12 @@ void MacroConditionAudioEdit::BalanceChanged(const NumberVariable<double> &value
 	_entryData->_balance = value;
 }
 
+void MacroConditionAudioEdit::TrackChanged(const NumberVariable<int> &value)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_track = value;
+}
+
 void MacroConditionAudioEdit::VolumeDBChanged(
 	const NumberVariable<double> &value)
 {
@@ -692,6 +719,8 @@ void MacroConditionAudioEdit::CheckTypeChanged(int idx)
 	} else if (_entryData->GetType() ==
 		   MacroConditionAudio::Type::CONFIGURED_VOLUME) {
 		populateVolumeConditionSelection(_condition);
+	} else if (_entryData->GetType() == MacroConditionAudio::Type::TRACK) {
+		_condition->clear();
 	}
 	SetWidgetVisibility();
 }
@@ -708,6 +737,7 @@ void MacroConditionAudioEdit::UpdateEntryData()
 	_syncOffset->SetValue(_entryData->_syncOffset);
 	_monitorTypes->setCurrentIndex(_entryData->_monitorType);
 	_balance->SetDoubleValue(_entryData->_balance);
+	_track->SetValue(_entryData->_track);
 	_checkTypes->setCurrentIndex(
 		_checkTypes->findData(static_cast<int>(_entryData->GetType())));
 
@@ -748,26 +778,63 @@ void MacroConditionAudioEdit::SetWidgetVisibility()
 		return;
 	}
 
+	_layout->removeWidget(_checkTypes);
+	_layout->removeWidget(_sources);
+	_layout->removeWidget(_condition);
+	_layout->removeWidget(_volumePercent);
+	_layout->removeWidget(_volumeDB);
+	_layout->removeWidget(_percentDBToggle);
+	_layout->removeWidget(_syncOffset);
+	_layout->removeWidget(_monitorTypes);
+	_layout->removeWidget(_track);
+	ClearLayout(_layout);
+
+	const std::unordered_map<std::string, QWidget *> placeholders = {
+		{"{{checkType}}", _checkTypes},
+		{"{{audioSources}}", _sources},
+		{"{{condition}}", _condition},
+		{"{{volume}}", _volumePercent},
+		{"{{volumeDB}}", _volumeDB},
+		{"{{percentDBToggle}}", _percentDBToggle},
+		{"{{syncOffset}}", _syncOffset},
+		{"{{monitorTypes}}", _monitorTypes},
+		{"{{track}}", _track},
+	};
+
+	const bool isTrack = _entryData->GetType() ==
+			     MacroConditionAudio::Type::TRACK;
+	PlaceWidgets(
+		obs_module_text(
+			isTrack ? "AdvSceneSwitcher.condition.audio.layout.track"
+				: "AdvSceneSwitcher.condition.audio.entry"),
+		_layout, placeholders);
+
 	_condition->setVisible(
-		_entryData->GetType() ==
+		!isTrack &&
-			MacroConditionAudio::Type::OUTPUT_VOLUME ||
+		(_entryData->GetType() ==
-		_entryData->GetType() ==
+			 MacroConditionAudio::Type::OUTPUT_VOLUME ||
-			MacroConditionAudio::Type::CONFIGURED_VOLUME ||
+		 _entryData->GetType() ==
-		_entryData->GetType() == MacroConditionAudio::Type::BALANCE ||
+			 MacroConditionAudio::Type::CONFIGURED_VOLUME ||
-		_entryData->GetType() ==
+		 _entryData->GetType() == MacroConditionAudio::Type::BALANCE ||
-			MacroConditionAudio::Type::SYNC_OFFSET);
+		 _entryData->GetType() ==
-	_syncOffset->setVisible(_entryData->GetType() ==
+			 MacroConditionAudio::Type::SYNC_OFFSET));
-				MacroConditionAudio::Type::SYNC_OFFSET);
+	_syncOffset->setVisible(!isTrack &&
-	_monitorTypes->setVisible(_entryData->GetType() ==
+				_entryData->GetType() ==
-				  MacroConditionAudio::Type::MONITOR);
+					MacroConditionAudio::Type::SYNC_OFFSET);
+	_monitorTypes->setVisible(!isTrack &&
+				  _entryData->GetType() ==
+					  MacroConditionAudio::Type::MONITOR);
+	_track->setVisible(isTrack);
+	_volumePercent->setVisible(!isTrack && HasVolumeControl() &&
+				   !_entryData->_useDb);
+	_volumeDB->setVisible(!isTrack && HasVolumeControl() &&
+			      _entryData->_useDb);
+	_percentDBToggle->setText(_entryData->_useDb ? "dB" : "%");
+	_percentDBToggle->setVisible(!isTrack && HasVolumeControl());
 	_balance->setVisible(_entryData->GetType() ==
 			     MacroConditionAudio::Type::BALANCE);
 	_volMeter->setVisible(_entryData->GetType() ==
 			      MacroConditionAudio::Type::OUTPUT_VOLUME);
-	_volumePercent->setVisible(HasVolumeControl() && !_entryData->_useDb);
-	_volumeDB->setVisible(HasVolumeControl() && _entryData->_useDb);
-	_percentDBToggle->setText(_entryData->_useDb ? "dB" : "%");
-	_percentDBToggle->setVisible(HasVolumeControl());
 	adjustSize();
 }
 

plugins/base/macro-condition-audio.hpp

@@ -5,6 +5,7 @@
 #include "source-selection.hpp"
 
 #include <limits>
+#include <QHBoxLayout>
 #include <QWidget>
 #include <QComboBox>
 #include <chrono>
@@ -36,6 +37,7 @@ public:
 		SYNC_OFFSET,
 		MONITOR,
 		BALANCE,
+		TRACK,
 	};
 	void SetType(const Type &);
 	Type GetType() const { return _checkType; }
@@ -60,6 +62,7 @@ public:
 	IntVariable _syncOffset = 0;
 	obs_monitoring_type _monitorType = OBS_MONITORING_TYPE_NONE;
 	DoubleVariable _balance = 0.5;
+	IntVariable _track = 1;
 	OutputCondition _outputCondition = OutputCondition::ABOVE;
 	VolumeCondition _volumeCondition = VolumeCondition::ABOVE;
 	obs_volmeter_t *_volmeter = nullptr;
@@ -70,6 +73,7 @@ private:
 	bool CheckSyncOffset();
 	bool CheckMonitor();
 	bool CheckBalance();
+	bool CheckTrack();
 	void SetupTempVars();
 	float GetVolumePeak();
 
@@ -111,6 +115,7 @@ private slots:
 	void VolumeDBChanged(const NumberVariable<double> &value);
 	void PercentDBClicked();
 	void SyncSliderAndValueSelection(bool sliderMoved);
+	void TrackChanged(const NumberVariable<int> &value);
 
 signals:
 	void HeaderInfoChanged(const QString &);
@@ -119,6 +124,7 @@ private:
 	void SetWidgetVisibility();
 	bool HasVolumeControl() const;
 
+	QHBoxLayout *_layout;
 	QComboBox *_checkTypes;
 	SourceSelectionWidget *_sources;
 	QComboBox *_condition;
@@ -128,6 +134,7 @@ private:
 	VariableSpinBox *_syncOffset;
 	QComboBox *_monitorTypes;
 	SliderSpinBox *_balance;
+	VariableSpinBox *_track;
 	VolControl *_volMeter = nullptr;
 
 	std::shared_ptr<MacroConditionAudio> _entryData;

plugins/now-playing/CMakeLists.txt

@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.14)
+project(advanced-scene-switcher-now-playing)
+
+if(NOT WIN32)
+  message(WARNING "Now playing condition is only supported on Windows.")
+  return()
+endif()
+
+add_library(${PROJECT_NAME} MODULE)
+target_sources(${PROJECT_NAME} PRIVATE macro-condition-now-playing.cpp
+                                       macro-condition-now-playing.hpp)
+
+target_link_libraries(${PROJECT_NAME} PRIVATE windowsapp)
+
+setup_advss_plugin(${PROJECT_NAME})
+set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "")
+install_advss_plugin(${PROJECT_NAME})

plugins/now-playing/macro-condition-now-playing.cpp

@@ -0,0 +1,338 @@
+#include "macro-condition-now-playing.hpp"
+#include "layout-helpers.hpp"
+#include "sync-helpers.hpp"
+
+#include <util/base.h>
+
+#include <roapi.h>
+#include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Media.Control.h>
+
+namespace advss {
+
+using namespace winrt::Windows::Media::Control;
+
+const std::string MacroConditionNowPlaying::id = "now_playing";
+
+bool MacroConditionNowPlaying::_registered = MacroConditionFactory::Register(
+	MacroConditionNowPlaying::id,
+	{MacroConditionNowPlaying::Create, MacroConditionNowPlayingEdit::Create,
+	 "AdvSceneSwitcher.condition.nowPlaying"});
+
+// ---------------------------------------------------------------------------
+
+struct SessionInfo {
+	bool hasSession = false;
+	std::string title;
+	std::string artist;
+	std::string album;
+	std::string appName;
+	GlobalSystemMediaTransportControlsSessionPlaybackStatus playbackStatus =
+		GlobalSystemMediaTransportControlsSessionPlaybackStatus::Closed;
+};
+
+static bool initWinRT()
+{
+	HRESULT hr = RoInitialize(RO_INIT_MULTITHREADED);
+	// S_OK: initialized, S_FALSE: already initialized with same type,
+	// RPC_E_CHANGED_MODE: thread is STA (OBS UI thread) - WinRT still usable
+	return SUCCEEDED(hr) || hr == RPC_E_CHANGED_MODE;
+}
+
+static SessionInfo getCurrentSessionInfo()
+{
+	thread_local bool initialized = initWinRT();
+	(void)initialized;
+
+	SessionInfo info;
+
+	try {
+		auto manager =
+			GlobalSystemMediaTransportControlsSessionManager::
+				RequestAsync()
+					.get();
+		auto session = manager.GetCurrentSession();
+		if (!session) {
+			return info;
+		}
+
+		info.hasSession = true;
+		info.appName = winrt::to_string(session.SourceAppUserModelId());
+
+		auto playbackInfo = session.GetPlaybackInfo();
+		info.playbackStatus = playbackInfo.PlaybackStatus();
+
+		auto props = session.TryGetMediaPropertiesAsync().get();
+		if (props) {
+			info.title = winrt::to_string(props.Title());
+			info.artist = winrt::to_string(props.Artist());
+			info.album = winrt::to_string(props.AlbumTitle());
+		}
+	} catch (const winrt::hresult_error &e) {
+		blog(LOG_WARNING, "now playing: WinRT error 0x%08X",
+		     static_cast<uint32_t>(e.code()));
+	}
+
+	return info;
+}
+
+static std::string PlaybackStatusToString(
+	GlobalSystemMediaTransportControlsSessionPlaybackStatus status)
+{
+	switch (status) {
+	case GlobalSystemMediaTransportControlsSessionPlaybackStatus::Playing:
+		return "Playing";
+	case GlobalSystemMediaTransportControlsSessionPlaybackStatus::Paused:
+		return "Paused";
+	case GlobalSystemMediaTransportControlsSessionPlaybackStatus::Stopped:
+		return "Stopped";
+	case GlobalSystemMediaTransportControlsSessionPlaybackStatus::Opened:
+		return "Opening";
+	case GlobalSystemMediaTransportControlsSessionPlaybackStatus::Changing:
+		return "Changing";
+	default:
+		return "Closed";
+	}
+}
+
+// ---------------------------------------------------------------------------
+
+bool MacroConditionNowPlaying::CheckCondition()
+{
+	const auto info = getCurrentSessionInfo();
+
+	SetTempVarValue("title", info.title);
+	SetTempVarValue("artist", info.artist);
+	SetTempVarValue("album", info.album);
+	SetTempVarValue("appName", info.appName);
+	SetTempVarValue("playbackStatus",
+			PlaybackStatusToString(info.playbackStatus));
+
+	if (!info.hasSession) {
+		return false;
+	}
+
+	auto textMatches = [this](const std::string &field) -> bool {
+		const QString pattern = QString::fromStdString(_matchText);
+		const QString value = QString::fromStdString(field);
+		if (_regex.Enabled()) {
+			return _regex.Matches(value, pattern);
+		}
+		return value == pattern;
+	};
+
+	switch (_checkType) {
+	case CheckType::PLAYBACK_STATE: {
+		using S =
+			GlobalSystemMediaTransportControlsSessionPlaybackStatus;
+		switch (_playbackState) {
+		case PlaybackState::PLAYING:
+			return info.playbackStatus == S::Playing;
+		case PlaybackState::PAUSED:
+			return info.playbackStatus == S::Paused;
+		case PlaybackState::STOPPED:
+			return info.playbackStatus == S::Stopped;
+		case PlaybackState::OPENING:
+			return info.playbackStatus == S::Opened;
+		case PlaybackState::CHANGING:
+			return info.playbackStatus == S::Changing;
+		}
+		break;
+	}
+	case CheckType::TITLE:
+		return textMatches(info.title);
+	case CheckType::ARTIST:
+		return textMatches(info.artist);
+	case CheckType::ALBUM:
+		return textMatches(info.album);
+	case CheckType::APP_NAME:
+		return textMatches(info.appName);
+	}
+
+	return false;
+}
+
+bool MacroConditionNowPlaying::Save(obs_data_t *obj) const
+{
+	MacroCondition::Save(obj);
+	obs_data_set_int(obj, "checkType", static_cast<int>(_checkType));
+	obs_data_set_int(obj, "playbackState",
+			 static_cast<int>(_playbackState));
+	_matchText.Save(obj, "matchText");
+	_regex.Save(obj);
+	return true;
+}
+
+bool MacroConditionNowPlaying::Load(obs_data_t *obj)
+{
+	MacroCondition::Load(obj);
+	_checkType = static_cast<CheckType>(obs_data_get_int(obj, "checkType"));
+	_playbackState = static_cast<PlaybackState>(
+		obs_data_get_int(obj, "playbackState"));
+	_matchText.Load(obj, "matchText");
+	_regex.Load(obj);
+	return true;
+}
+
+void MacroConditionNowPlaying::SetupTempVars()
+{
+	AddTempvar(
+		"title",
+		obs_module_text("AdvSceneSwitcher.tempVar.nowPlaying.title"));
+	AddTempvar(
+		"artist",
+		obs_module_text("AdvSceneSwitcher.tempVar.nowPlaying.artist"));
+	AddTempvar(
+		"album",
+		obs_module_text("AdvSceneSwitcher.tempVar.nowPlaying.album"));
+	AddTempvar(
+		"appName",
+		obs_module_text("AdvSceneSwitcher.tempVar.nowPlaying.appName"));
+	AddTempvar(
+		"playbackStatus",
+		obs_module_text(
+			"AdvSceneSwitcher.tempVar.nowPlaying.playbackStatus"));
+}
+
+// ---------------------------------------------------------------------------
+
+static void populateCheckTypeSelection(QComboBox *list)
+{
+	static const std::map<MacroConditionNowPlaying::CheckType, std::string> checkTypes = {
+		{MacroConditionNowPlaying::CheckType::PLAYBACK_STATE,
+		 "AdvSceneSwitcher.condition.nowPlaying.checkType.playbackState"},
+		{MacroConditionNowPlaying::CheckType::TITLE,
+		 "AdvSceneSwitcher.condition.nowPlaying.checkType.title"},
+		{MacroConditionNowPlaying::CheckType::ARTIST,
+		 "AdvSceneSwitcher.condition.nowPlaying.checkType.artist"},
+		{MacroConditionNowPlaying::CheckType::ALBUM,
+		 "AdvSceneSwitcher.condition.nowPlaying.checkType.album"},
+		{MacroConditionNowPlaying::CheckType::APP_NAME,
+		 "AdvSceneSwitcher.condition.nowPlaying.checkType.appName"},
+	};
+
+	for (const auto &[type, name] : checkTypes) {
+		list->addItem(obs_module_text(name.c_str()),
+			      static_cast<int>(type));
+	}
+}
+
+static void populatePlaybackStateSelection(QComboBox *list)
+{
+	static const std::map<MacroConditionNowPlaying::PlaybackState, std::string> playbackStates = {
+		{MacroConditionNowPlaying::PlaybackState::PLAYING,
+		 "AdvSceneSwitcher.condition.nowPlaying.playbackState.playing"},
+		{MacroConditionNowPlaying::PlaybackState::PAUSED,
+		 "AdvSceneSwitcher.condition.nowPlaying.playbackState.paused"},
+		{MacroConditionNowPlaying::PlaybackState::STOPPED,
+		 "AdvSceneSwitcher.condition.nowPlaying.playbackState.stopped"},
+		{MacroConditionNowPlaying::PlaybackState::OPENING,
+		 "AdvSceneSwitcher.condition.nowPlaying.playbackState.opening"},
+		{MacroConditionNowPlaying::PlaybackState::CHANGING,
+		 "AdvSceneSwitcher.condition.nowPlaying.playbackState.changing"},
+	};
+
+	for (const auto &[state, name] : playbackStates) {
+		list->addItem(obs_module_text(name.c_str()),
+			      static_cast<int>(state));
+	}
+}
+
+MacroConditionNowPlayingEdit::MacroConditionNowPlayingEdit(
+	QWidget *parent, std::shared_ptr<MacroConditionNowPlaying> entryData)
+	: QWidget(parent),
+	  _checkType(new QComboBox(this)),
+	  _playbackState(new QComboBox(this)),
+	  _matchText(new VariableLineEdit(this)),
+	  _regex(new RegexConfigWidget(this))
+{
+	populateCheckTypeSelection(_checkType);
+	populatePlaybackStateSelection(_playbackState);
+
+	connect(_checkType, QOverload<int>::of(&QComboBox::currentIndexChanged),
+		this, &MacroConditionNowPlayingEdit::CheckTypeChanged);
+	connect(_playbackState,
+		QOverload<int>::of(&QComboBox::currentIndexChanged), this,
+		&MacroConditionNowPlayingEdit::PlaybackStateChanged);
+	connect(_matchText, &VariableLineEdit::textEdited, this,
+		&MacroConditionNowPlayingEdit::MatchTextChanged);
+	connect(_regex, &RegexConfigWidget::RegexConfigChanged, this,
+		&MacroConditionNowPlayingEdit::RegexChanged);
+
+	_layout = new QHBoxLayout();
+	_layout->addWidget(_checkType);
+	_layout->addWidget(_playbackState);
+	_layout->addWidget(_matchText);
+	_layout->addWidget(_regex);
+	setLayout(_layout);
+
+	_entryData = entryData;
+	UpdateEntryData();
+	_loading = false;
+}
+
+void MacroConditionNowPlayingEdit::UpdateEntryData()
+{
+	if (!_entryData) {
+		return;
+	}
+
+	_checkType->setCurrentIndex(
+		_checkType->findData(static_cast<int>(_entryData->_checkType)));
+	_playbackState->setCurrentIndex(_playbackState->findData(
+		static_cast<int>(_entryData->_playbackState)));
+	_matchText->setText(QString::fromStdString(_entryData->_matchText));
+	_regex->SetRegexConfig(_entryData->_regex);
+
+	SetWidgetVisibility();
+}
+
+void MacroConditionNowPlayingEdit::CheckTypeChanged(int)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_checkType =
+		static_cast<MacroConditionNowPlaying::CheckType>(
+			_checkType->currentData().toInt());
+	SetWidgetVisibility();
+}
+
+void MacroConditionNowPlayingEdit::PlaybackStateChanged(int)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_playbackState =
+		static_cast<MacroConditionNowPlaying::PlaybackState>(
+			_playbackState->currentData().toInt());
+}
+
+void MacroConditionNowPlayingEdit::MatchTextChanged(const QString &text)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_matchText = text.toStdString();
+}
+
+void MacroConditionNowPlayingEdit::RegexChanged(const RegexConfig &regex)
+{
+	GUARD_LOADING_AND_LOCK();
+	_entryData->_regex = regex;
+}
+
+void MacroConditionNowPlayingEdit::SetWidgetVisibility()
+{
+	const bool isStateCheck =
+		_entryData->_checkType ==
+		MacroConditionNowPlaying::CheckType::PLAYBACK_STATE;
+	_playbackState->setVisible(isStateCheck);
+	_matchText->setVisible(!isStateCheck);
+	_regex->setVisible(!isStateCheck);
+
+	if (isStateCheck) {
+		AddStretchIfNecessary(_layout);
+	} else {
+		RemoveStretchIfPresent(_layout);
+	}
+
+	adjustSize();
+	updateGeometry();
+}
+
+} // namespace advss

plugins/now-playing/macro-condition-now-playing.hpp

@@ -0,0 +1,86 @@
+#pragma once
+#include "macro-condition-edit.hpp"
+#include "regex-config.hpp"
+#include "variable-line-edit.hpp"
+
+#include <QComboBox>
+
+namespace advss {
+
+class MacroConditionNowPlaying : public MacroCondition {
+public:
+	enum class CheckType {
+		PLAYBACK_STATE,
+		TITLE,
+		ARTIST,
+		ALBUM,
+		APP_NAME,
+	};
+
+	enum class PlaybackState {
+		PLAYING,
+		PAUSED,
+		STOPPED,
+		OPENING,
+		CHANGING,
+	};
+
+	MacroConditionNowPlaying(Macro *m) : MacroCondition(m) {}
+	bool CheckCondition();
+	bool Save(obs_data_t *obj) const;
+	bool Load(obs_data_t *obj);
+	std::string GetId() const { return id; }
+	static std::shared_ptr<MacroCondition> Create(Macro *m)
+	{
+		return std::make_shared<MacroConditionNowPlaying>(m);
+	}
+
+	CheckType _checkType = CheckType::PLAYBACK_STATE;
+	PlaybackState _playbackState = PlaybackState::PLAYING;
+	StringVariable _matchText;
+	RegexConfig _regex;
+
+private:
+	void SetupTempVars();
+
+	static bool _registered;
+	static const std::string id;
+};
+
+class MacroConditionNowPlayingEdit : public QWidget {
+	Q_OBJECT
+
+public:
+	MacroConditionNowPlayingEdit(
+		QWidget *parent,
+		std::shared_ptr<MacroConditionNowPlaying> cond = nullptr);
+	void UpdateEntryData();
+	static QWidget *Create(QWidget *parent,
+			       std::shared_ptr<MacroCondition> cond)
+	{
+		return new MacroConditionNowPlayingEdit(
+			parent,
+			std::dynamic_pointer_cast<MacroConditionNowPlaying>(
+				cond));
+	}
+
+private slots:
+	void CheckTypeChanged(int);
+	void PlaybackStateChanged(int);
+	void MatchTextChanged(const QString &);
+	void RegexChanged(const RegexConfig &);
+
+private:
+	void SetWidgetVisibility();
+
+	QHBoxLayout *_layout;
+	QComboBox *_checkType;
+	QComboBox *_playbackState;
+	VariableLineEdit *_matchText;
+	RegexConfigWidget *_regex;
+
+	std::shared_ptr<MacroConditionNowPlaying> _entryData;
+	bool _loading = true;
+};
+
+} // namespace advss

plugins/speech/CMakeLists.txt

@@ -61,9 +61,14 @@ function(_advss_whisper_suppress_werror dir)
     endif()
     target_compile_options(
       ${_target}
-      PRIVATE $<$<C_COMPILER_ID:GNU,Clang,AppleClang>:-Wno-error>
+      PRIVATE $<$<C_COMPILER_ID:GNU,Clang,AppleClang>:-Wno-error
-              $<$<CXX_COMPILER_ID:GNU,Clang,AppleClang>:-Wno-error>
+              -Wno-shorten-64-to-32
-              $<$<C_COMPILER_ID:MSVC>:/WX-> $<$<CXX_COMPILER_ID:MSVC>:/WX->)
+              -Wno-ambiguous-macro>
+              $<$<CXX_COMPILER_ID:GNU,Clang,AppleClang>:-Wno-error
+              -Wno-shorten-64-to-32
+              -Wno-ambiguous-macro>
+              $<$<C_COMPILER_ID:MSVC>:/WX->
+              $<$<CXX_COMPILER_ID:MSVC>:/WX->)
   endforeach()
 endfunction()
 

tests/stubs/macro-edit.cpp

@@ -110,7 +110,9 @@ void MacroEdit::HighlightControls() const {}
 void MacroEdit::PopulateMacroActions(Macro &, uint32_t) {}
 void MacroEdit::PopulateMacroElseActions(Macro &, uint32_t) {}
 void MacroEdit::PopulateMacroConditions(Macro &, uint32_t) {}
-void MacroEdit::SetupMacroSegmentSelection(MacroSection, int) {}
+void MacroEdit::InsertSegmentWidget(SegmentType, int) {}
+void MacroEdit::RemoveSegmentWidget(SegmentType, int) {}
+void MacroEdit::SetupMacroSegmentSelection(SegmentType, int) {}
 void MacroEdit::SetupContextMenu(const QPoint &,
 				 const std::function<void(MacroEdit *, int)> &,
 				 const std::function<void(MacroEdit *)> &,