move saving and loading to separate files

src/executable-switch.cpp

@@ -193,3 +193,60 @@ void SwitcherData::checkExeSwitch(bool &match, OBSWeakSource &scene,
 		}
 	}
 }
+
+void SwitcherData::saveExecutableSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *executableArray = obs_data_array_create();
+	for (ExecutableSceneSwitch &s : switcher->executableSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.mScene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.mTransition);
+
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "scene", sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(array_obj, "exefile",
+					    s.mExe.toUtf8());
+			obs_data_set_bool(array_obj, "infocus", s.mInFocus);
+			obs_data_array_push_back(executableArray, array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "executableSwitches", executableArray);
+	obs_data_array_release(executableArray);
+}
+
+void SwitcherData::loadExecutableSwitches(obs_data_t *obj)
+{
+	switcher->executableSwitches.clear();
+
+	obs_data_array_t *executableArray =
+		obs_data_get_array(obj, "executableSwitches");
+	size_t count = obs_data_array_count(executableArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(executableArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		const char *exe = obs_data_get_string(array_obj, "exefile");
+		bool infocus = obs_data_get_bool(array_obj, "infocus");
+
+		switcher->executableSwitches.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition), exe, infocus);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(executableArray);
+}

src/file-switch.cpp

@@ -245,3 +245,75 @@ void SceneSwitcher::on_fileScenesList_currentRowChanged(int idx)
 	ui->fileContentRegExCheckBox->setChecked(s.useRegex);
 	ui->fileContentTimeCheckBox->setChecked(s.useTime);
 }
+
+void SwitcherData::saveFileSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *fileArray = obs_data_array_create();
+	for (FileSwitch &s : switcher->fileSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "scene", sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(array_obj, "file", s.file.c_str());
+			obs_data_set_string(array_obj, "text", s.text.c_str());
+			obs_data_set_bool(array_obj, "useRegex", s.useRegex);
+			obs_data_set_bool(array_obj, "useTime", s.useTime);
+			obs_data_array_push_back(fileArray, array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "fileSwitches", fileArray);
+	obs_data_array_release(fileArray);
+
+	obs_data_set_bool(obj, "readEnabled", switcher->fileIO.readEnabled);
+	obs_data_set_string(obj, "readPath", switcher->fileIO.readPath.c_str());
+	obs_data_set_bool(obj, "writeEnabled", switcher->fileIO.writeEnabled);
+	obs_data_set_string(obj, "writePath",
+			    switcher->fileIO.writePath.c_str());
+}
+
+void SwitcherData::loadFileSwitches(obs_data_t *obj)
+{
+	switcher->fileSwitches.clear();
+	obs_data_array_t *fileArray = obs_data_get_array(obj, "fileSwitches");
+	size_t count = obs_data_array_count(fileArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(fileArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		const char *file = obs_data_get_string(array_obj, "file");
+		const char *text = obs_data_get_string(array_obj, "text");
+		bool useRegex = obs_data_get_bool(array_obj, "useRegex");
+		bool useTime = obs_data_get_bool(array_obj, "useTime");
+
+		switcher->fileSwitches.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition), file, text,
+			useRegex, useTime);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(fileArray);
+
+	obs_data_set_default_bool(obj, "readEnabled", false);
+	switcher->fileIO.readEnabled = obs_data_get_bool(obj, "readEnabled");
+	switcher->fileIO.readPath = obs_data_get_string(obj, "readPath");
+	obs_data_set_default_bool(obj, "writeEnabled", false);
+	switcher->fileIO.writeEnabled = obs_data_get_bool(obj, "writeEnabled");
+	switcher->fileIO.writePath = obs_data_get_string(obj, "writePath");
+}

src/general.cpp

@@ -102,3 +102,103 @@ void SceneSwitcher::closeEvent(QCloseEvent *)
 {
 	obs_frontend_save();
 }
+
+void SwitcherData::saveGeneralSettings(obs_data_t *obj)
+{
+	obs_data_set_int(obj, "interval", switcher->interval);
+
+	std::string nonMatchingSceneName =
+		GetWeakSourceName(switcher->nonMatchingScene);
+	obs_data_set_string(obj, "non_matching_scene",
+			    nonMatchingSceneName.c_str());
+	obs_data_set_int(obj, "switch_if_not_matching",
+			 switcher->switchIfNotMatching);
+
+	obs_data_set_bool(obj, "active", !switcher->stop);
+
+	std::string autoStopSceneName =
+		GetWeakSourceName(switcher->autoStopScene);
+	obs_data_set_bool(obj, "autoStopEnable", switcher->autoStopEnable);
+	obs_data_set_string(obj, "autoStopSceneName",
+			    autoStopSceneName.c_str());
+
+	obs_data_set_int(obj, "priority0",
+			 switcher->functionNamesByPriority[0]);
+	obs_data_set_int(obj, "priority1",
+			 switcher->functionNamesByPriority[1]);
+	obs_data_set_int(obj, "priority2",
+			 switcher->functionNamesByPriority[2]);
+	obs_data_set_int(obj, "priority3",
+			 switcher->functionNamesByPriority[3]);
+	obs_data_set_int(obj, "priority4",
+			 switcher->functionNamesByPriority[4]);
+	obs_data_set_int(obj, "priority5",
+			 switcher->functionNamesByPriority[5]);
+	obs_data_set_int(obj, "priority6",
+			 switcher->functionNamesByPriority[6]);
+	obs_data_set_int(obj, "priority7",
+			 switcher->functionNamesByPriority[7]);
+
+	obs_data_set_int(obj, "threadPriority", switcher->threadPriority);
+}
+
+void SwitcherData::loadGeneralSettings(obs_data_t *obj)
+{
+	obs_data_set_default_int(obj, "interval", DEFAULT_INTERVAL);
+	switcher->interval = obs_data_get_int(obj, "interval");
+
+	obs_data_set_default_int(obj, "switch_if_not_matching", NO_SWITCH);
+	switcher->switchIfNotMatching =
+		(NoMatch)obs_data_get_int(obj, "switch_if_not_matching");
+	std::string nonMatchingScene =
+		obs_data_get_string(obj, "non_matching_scene");
+	switcher->nonMatchingScene =
+		GetWeakSourceByName(nonMatchingScene.c_str());
+
+	switcher->stop = !obs_data_get_bool(obj, "active");
+
+	std::string autoStopScene =
+		obs_data_get_string(obj, "autoStopSceneName");
+	switcher->autoStopEnable = obs_data_get_bool(obj, "autoStopEnable");
+	switcher->autoStopScene = GetWeakSourceByName(autoStopScene.c_str());
+
+	obs_data_set_default_int(obj, "priority0", DEFAULT_PRIORITY_0);
+	obs_data_set_default_int(obj, "priority1", DEFAULT_PRIORITY_1);
+	obs_data_set_default_int(obj, "priority2", DEFAULT_PRIORITY_2);
+	obs_data_set_default_int(obj, "priority3", DEFAULT_PRIORITY_3);
+	obs_data_set_default_int(obj, "priority4", DEFAULT_PRIORITY_4);
+	obs_data_set_default_int(obj, "priority5", DEFAULT_PRIORITY_5);
+	obs_data_set_default_int(obj, "priority6", DEFAULT_PRIORITY_6);
+	obs_data_set_default_int(obj, "priority7", DEFAULT_PRIORITY_7);
+
+	switcher->functionNamesByPriority[0] =
+		(obs_data_get_int(obj, "priority0"));
+	switcher->functionNamesByPriority[1] =
+		(obs_data_get_int(obj, "priority1"));
+	switcher->functionNamesByPriority[2] =
+		(obs_data_get_int(obj, "priority2"));
+	switcher->functionNamesByPriority[3] =
+		(obs_data_get_int(obj, "priority3"));
+	switcher->functionNamesByPriority[4] =
+		(obs_data_get_int(obj, "priority4"));
+	switcher->functionNamesByPriority[5] =
+		(obs_data_get_int(obj, "priority5"));
+	switcher->functionNamesByPriority[6] =
+		(obs_data_get_int(obj, "priority6"));
+	switcher->functionNamesByPriority[6] =
+		(obs_data_get_int(obj, "priority7"));
+	if (!switcher->prioFuncsValid()) {
+		switcher->functionNamesByPriority[0] = (DEFAULT_PRIORITY_0);
+		switcher->functionNamesByPriority[1] = (DEFAULT_PRIORITY_1);
+		switcher->functionNamesByPriority[2] = (DEFAULT_PRIORITY_2);
+		switcher->functionNamesByPriority[3] = (DEFAULT_PRIORITY_3);
+		switcher->functionNamesByPriority[4] = (DEFAULT_PRIORITY_4);
+		switcher->functionNamesByPriority[5] = (DEFAULT_PRIORITY_5);
+		switcher->functionNamesByPriority[6] = (DEFAULT_PRIORITY_6);
+		switcher->functionNamesByPriority[7] = (DEFAULT_PRIORITY_7);
+	}
+
+	obs_data_set_default_int(obj, "threadPriority",
+				 QThread::NormalPriority);
+	switcher->threadPriority = obs_data_get_int(obj, "threadPriority");
+}

src/headers/switcher-data-structs.hpp

@@ -373,6 +373,32 @@ struct SwitcherData {
 	void checkTimeSwitch(bool &match, OBSWeakSource &scene,
 			     OBSWeakSource &transition);
 
+	void saveWindowTitleSwitches(obs_data_t *obj);
+	void saveScreenRegionSwitches(obs_data_t *obj);
+	void savePauseSwitches(obs_data_t *obj);
+	void saveSceneRoundTripSwitches(obs_data_t *obj);
+	void saveSceneTransitions(obs_data_t *obj);
+	void saveIdleSwitches(obs_data_t *obj);
+	void saveExecutableSwitches(obs_data_t *obj);
+	void saveRandomSwitches(obs_data_t *obj);
+	void saveFileSwitches(obs_data_t *obj);
+	void saveMediaSwitches(obs_data_t *obj);
+	void saveTimeSwitches(obs_data_t *obj);
+	void saveGeneralSettings(obs_data_t *obj);
+
+	void loadWindowTitleSwitches(obs_data_t *obj);
+	void loadScreenRegionSwitches(obs_data_t *obj);
+	void loadPauseSwitches(obs_data_t *obj);
+	void loadSceneRoundTripSwitches(obs_data_t *obj);
+	void loadSceneTransitions(obs_data_t *obj);
+	void loadIdleSwitches(obs_data_t *obj);
+	void loadExecutableSwitches(obs_data_t *obj);
+	void loadRandomSwitches(obs_data_t *obj);
+	void loadFileSwitches(obs_data_t *obj);
+	void loadMediaSwitches(obs_data_t *obj);
+	void loadTimeSwitches(obs_data_t *obj);
+	void loadGeneralSettings(obs_data_t *obj);
+
 	void Prune()
 	{
 		for (size_t i = 0; i < windowSwitches.size(); i++) {

src/idle-switch.cpp

@@ -199,3 +199,62 @@ int SceneSwitcher::IgnoreIdleWindowsFindByData(const QString &window)
 
 	return idx;
 }
+
+void SwitcherData::saveIdleSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *ignoreIdleWindowsArray = obs_data_array_create();
+	for (std::string &window : switcher->ignoreIdleWindows) {
+		obs_data_t *array_obj = obs_data_create();
+		obs_data_set_string(array_obj, "window", window.c_str());
+		obs_data_array_push_back(ignoreIdleWindowsArray, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "ignoreIdleWindows", ignoreIdleWindowsArray);
+	obs_data_array_release(ignoreIdleWindowsArray);
+
+	std::string idleSceneName = GetWeakSourceName(switcher->idleData.scene);
+	std::string idleTransitionName =
+		GetWeakSourceName(switcher->idleData.transition);
+	obs_data_set_bool(obj, "idleEnable", switcher->idleData.idleEnable);
+	obs_data_set_string(obj, "idleSceneName",
+			    switcher->idleData.usePreviousScene
+				    ? PREVIOUS_SCENE_NAME
+				    : idleSceneName.c_str());
+	obs_data_set_string(obj, "idleTransitionName",
+			    idleTransitionName.c_str());
+	obs_data_set_int(obj, "idleTime", switcher->idleData.time);
+}
+
+void SwitcherData::loadIdleSwitches(obs_data_t *obj)
+{
+	switcher->ignoreIdleWindows.clear();
+
+	obs_data_array_t *ignoreIdleWindowsArray =
+		obs_data_get_array(obj, "ignoreIdleWindows");
+	size_t count = obs_data_array_count(ignoreIdleWindowsArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(ignoreIdleWindowsArray, i);
+
+		const char *window = obs_data_get_string(array_obj, "window");
+
+		switcher->ignoreIdleWindows.emplace_back(window);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(ignoreIdleWindowsArray);
+
+	std::string idleSceneName = obs_data_get_string(obj, "idleSceneName");
+	std::string idleTransitionName =
+		obs_data_get_string(obj, "idleTransitionName");
+	switcher->idleData.scene = GetWeakSourceByName(idleSceneName.c_str());
+	switcher->idleData.transition =
+		GetWeakTransitionByName(idleTransitionName.c_str());
+	obs_data_set_default_bool(obj, "idleEnable", false);
+	switcher->idleData.idleEnable = obs_data_get_bool(obj, "idleEnable");
+	obs_data_set_default_int(obj, "idleTime", DEFAULT_IDLE_TIME);
+	switcher->idleData.time = obs_data_get_int(obj, "idleTime");
+	switcher->idleData.usePreviousScene =
+		(idleSceneName == PREVIOUS_SCENE_NAME);
+}

src/media-switch.cpp

@@ -127,3 +127,80 @@ void SwitcherData::checkMediaSwitch(bool &match, OBSWeakSource &scene,
 		obs_source_release(source);
 	}
 }
+
+void SwitcherData::saveMediaSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *mediaArray = obs_data_array_create();
+	for (MediaSwitch &s : switcher->mediaSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.source);
+		obs_source_t *sceneSource = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if ((s.usePreviousScene || sceneSource) && source &&
+		    transition) {
+			const char *sourceName = obs_source_get_name(source);
+			const char *sceneName =
+				obs_source_get_name(sceneSource);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "source", sourceName);
+			obs_data_set_string(array_obj, "scene",
+					    s.usePreviousScene
+						    ? PREVIOUS_SCENE_NAME
+						    : sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_int(array_obj, "state", s.state);
+			obs_data_set_int(array_obj, "restriction",
+					 s.restriction);
+			obs_data_set_int(array_obj, "time", s.time);
+			obs_data_array_push_back(mediaArray, array_obj);
+		}
+		obs_source_release(source);
+		obs_source_release(sceneSource);
+		obs_source_release(transition);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "mediaSwitches", mediaArray);
+	obs_data_array_release(mediaArray);
+}
+
+void SwitcherData::loadMediaSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *mediaArray = obs_data_get_array(obj, "mediaSwitches");
+	switcher->mediaSwitches.clear();
+	size_t count = obs_data_array_count(mediaArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(mediaArray, i);
+
+		const char *source = obs_data_get_string(array_obj, "source");
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		obs_media_state state =
+			(obs_media_state)obs_data_get_int(array_obj, "state");
+		time_restriction restriction =
+			(time_restriction)obs_data_get_int(array_obj,
+							   "restriction");
+		uint64_t time = obs_data_get_int(array_obj, "time");
+
+		std::string mediaStr = MakeMediaSwitchName(source, scene,
+							   transition, state,
+							   restriction, time)
+					       .toUtf8()
+					       .constData();
+
+		switcher->mediaSwitches.emplace_back(
+			GetWeakSourceByName(scene), GetWeakSourceByName(source),
+			GetWeakTransitionByName(transition), state, restriction,
+			time, (strcmp(scene, PREVIOUS_SCENE_NAME) == 0),
+			mediaStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(mediaArray);
+}

src/pause-switch.cpp

@@ -221,3 +221,75 @@ bool SwitcherData::checkPause()
 	}
 	return pause;
 }
+
+void SwitcherData::savePauseSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *pauseScenesArray = obs_data_array_create();
+	for (OBSWeakSource &scene : switcher->pauseScenesSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(scene);
+		if (source) {
+			const char *n = obs_source_get_name(source);
+			obs_data_set_string(array_obj, "pauseScene", n);
+			obs_data_array_push_back(pauseScenesArray, array_obj);
+			obs_source_release(source);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "pauseScenes", pauseScenesArray);
+	obs_data_array_release(pauseScenesArray);
+
+	obs_data_array_t *pauseWindowsArray = obs_data_array_create();
+	for (std::string &window : switcher->pauseWindowsSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+		obs_data_set_string(array_obj, "pauseWindow", window.c_str());
+		obs_data_array_push_back(pauseWindowsArray, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "pauseWindows", pauseWindowsArray);
+	obs_data_array_release(pauseWindowsArray);
+}
+
+void SwitcherData::loadPauseSwitches(obs_data_t *obj)
+{
+	switcher->pauseScenesSwitches.clear();
+
+	obs_data_array_t *pauseScenesArray =
+		obs_data_get_array(obj, "pauseScenes");
+	size_t count = obs_data_array_count(pauseScenesArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(pauseScenesArray, i);
+
+		const char *scene =
+			obs_data_get_string(array_obj, "pauseScene");
+
+		switcher->pauseScenesSwitches.emplace_back(
+			GetWeakSourceByName(scene));
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(pauseScenesArray);
+
+	switcher->pauseWindowsSwitches.clear();
+
+	obs_data_array_t *pauseWindowsArray =
+		obs_data_get_array(obj, "pauseWindows");
+	count = obs_data_array_count(pauseWindowsArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(pauseWindowsArray, i);
+
+		const char *window =
+			obs_data_get_string(array_obj, "pauseWindow");
+
+		switcher->pauseWindowsSwitches.emplace_back(window);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(pauseWindowsArray);
+}

src/random.cpp

@@ -135,3 +135,60 @@ void SwitcherData::checkRandom(bool &match, OBSWeakSource &scene,
 		break;
 	}
 }
+
+void SwitcherData::saveRandomSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *randomArray = obs_data_array_create();
+	for (RandomSwitch &s : switcher->randomSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "scene", sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_double(array_obj, "delay", s.delay);
+			obs_data_set_string(array_obj, "str",
+					    s.randomSwitchStr.c_str());
+			obs_data_array_push_back(randomArray, array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "randomSwitches", randomArray);
+	obs_data_array_release(randomArray);
+}
+
+void SwitcherData::loadRandomSwitches(obs_data_t *obj)
+{
+	switcher->randomSwitches.clear();
+
+	obs_data_array_t *randomArray =
+		obs_data_get_array(obj, "randomSwitches");
+	size_t count = obs_data_array_count(randomArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(randomArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		double delay = obs_data_get_double(array_obj, "delay");
+		const char *str = obs_data_get_string(array_obj, "str");
+
+		switcher->randomSwitches.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition), delay, str);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(randomArray);
+}

src/scene-round-trip.cpp

@@ -323,3 +323,93 @@ void SwitcherData::autoStopStreamAndRecording()
 	obs_source_release(currentSource);
 	obs_weak_source_release(ws);
 }
+
+void SwitcherData::saveSceneRoundTripSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *sceneRoundTripArray = obs_data_array_create();
+	for (SceneRoundTripSwitch &s : switcher->sceneRoundTripSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source1 = obs_weak_source_get_source(s.scene1);
+		obs_source_t *source2 = obs_weak_source_get_source(s.scene2);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if (source1 && (s.usePreviousScene || source2) && transition) {
+			const char *sceneName1 = obs_source_get_name(source1);
+			const char *sceneName2 = obs_source_get_name(source2);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "sceneRoundTripScene1",
+					    sceneName1);
+			obs_data_set_string(array_obj, "sceneRoundTripScene2",
+					    s.usePreviousScene
+						    ? PREVIOUS_SCENE_NAME
+						    : sceneName2);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_int(
+				array_obj, "sceneRoundTripDelay",
+				s.delay /
+					1000); //delay stored in two separate values
+			obs_data_set_int(
+				array_obj, "sceneRoundTripDelayMs",
+				s.delay %
+					1000); //to be compatible with older versions
+			obs_data_set_string(array_obj, "sceneRoundTripStr",
+					    s.sceneRoundTripStr.c_str());
+			obs_data_array_push_back(sceneRoundTripArray,
+						 array_obj);
+			obs_source_release(source1);
+			obs_source_release(source2);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "sceneRoundTrip", sceneRoundTripArray);
+	obs_data_array_release(sceneRoundTripArray);
+}
+
+void SwitcherData::loadSceneRoundTripSwitches(obs_data_t *obj)
+{
+	switcher->sceneRoundTripSwitches.clear();
+
+	obs_data_array_t *sceneRoundTripArray =
+		obs_data_get_array(obj, "sceneRoundTrip");
+	size_t count = obs_data_array_count(sceneRoundTripArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(sceneRoundTripArray, i);
+
+		const char *scene1 =
+			obs_data_get_string(array_obj, "sceneRoundTripScene1");
+		const char *scene2 =
+			obs_data_get_string(array_obj, "sceneRoundTripScene2");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		int delay = obs_data_get_int(
+			array_obj,
+			"sceneRoundTripDelay"); //delay stored in two separate values
+		delay = delay * 1000 +
+			obs_data_get_int(
+				array_obj,
+				"sceneRoundTripDelayMs"); //to be compatible with older versions
+		std::string str =
+			MakeSceneRoundTripSwitchName(scene1, scene2, transition,
+						     ((double)delay) / 1000.0)
+				.toUtf8()
+				.constData();
+		const char *sceneRoundTripStr = str.c_str();
+
+		switcher->sceneRoundTripSwitches.emplace_back(
+			GetWeakSourceByName(scene1),
+			GetWeakSourceByName(scene2),
+			GetWeakTransitionByName(transition), delay,
+			(strcmp(scene2, PREVIOUS_SCENE_NAME) == 0),
+			sceneRoundTripStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(sceneRoundTripArray);
+}

src/scene-transitions.cpp

@@ -277,3 +277,119 @@ obs_weak_source_t *getNextTransition(obs_weak_source_t *scene1,
 	}
 	return ws;
 }
+
+void SwitcherData::saveSceneTransitions(obs_data_t *obj)
+{
+	obs_data_array_t *sceneTransitionsArray = obs_data_array_create();
+	for (SceneTransition &s : switcher->sceneTransitions) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source1 = obs_weak_source_get_source(s.scene1);
+		obs_source_t *source2 = obs_weak_source_get_source(s.scene2);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if (source1 && source2 && transition) {
+			const char *sceneName1 = obs_source_get_name(source1);
+			const char *sceneName2 = obs_source_get_name(source2);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "Scene1", sceneName1);
+			obs_data_set_string(array_obj, "Scene2", sceneName2);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(array_obj, "Str",
+					    s.sceneTransitionStr.c_str());
+			obs_data_array_push_back(sceneTransitionsArray,
+						 array_obj);
+			obs_source_release(source1);
+			obs_source_release(source2);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "sceneTransitions", sceneTransitionsArray);
+	obs_data_array_release(sceneTransitionsArray);
+
+	obs_data_array_t *defaultTransitionsArray = obs_data_array_create();
+	for (DefaultSceneTransition &s : switcher->defaultSceneTransitions) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "Scene", sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(array_obj, "Str",
+					    s.sceneTransitionStr.c_str());
+			obs_data_array_push_back(defaultTransitionsArray,
+						 array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "defaultTransitions", defaultTransitionsArray);
+	obs_data_array_release(defaultTransitionsArray);
+}
+
+void SwitcherData::loadSceneTransitions(obs_data_t *obj)
+{
+	switcher->sceneTransitions.clear();
+
+	obs_data_array_t *sceneTransitionsArray =
+		obs_data_get_array(obj, "sceneTransitions");
+	size_t count = obs_data_array_count(sceneTransitionsArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(sceneTransitionsArray, i);
+
+		const char *scene1 = obs_data_get_string(array_obj, "Scene1");
+		const char *scene2 = obs_data_get_string(array_obj, "Scene2");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		const char *sceneTransitionsStr =
+			obs_data_get_string(array_obj, "Str");
+
+		switcher->sceneTransitions.emplace_back(
+			GetWeakSourceByName(scene1),
+			GetWeakSourceByName(scene2),
+			GetWeakTransitionByName(transition),
+			sceneTransitionsStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(sceneTransitionsArray);
+
+	switcher->defaultSceneTransitions.clear();
+
+	obs_data_array_t *defaultTransitionsArray =
+		obs_data_get_array(obj, "defaultTransitions");
+	count = obs_data_array_count(defaultTransitionsArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(defaultTransitionsArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "Scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		const char *sceneTransitionsStr =
+			obs_data_get_string(array_obj, "Str");
+
+		switcher->defaultSceneTransitions.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition),
+			sceneTransitionsStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(defaultTransitionsArray);
+}

src/screen-region-switch.cpp

@@ -155,3 +155,70 @@ int SceneSwitcher::ScreenRegionFindByData(const QString &region)
 
 	return idx;
 }
+
+void SwitcherData::saveScreenRegionSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *screenRegionArray = obs_data_array_create();
+	for (ScreenRegionSwitch &s : switcher->screenRegionSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "screenRegionScene",
+					    sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_int(array_obj, "minX", s.minX);
+			obs_data_set_int(array_obj, "minY", s.minY);
+			obs_data_set_int(array_obj, "maxX", s.maxX);
+			obs_data_set_int(array_obj, "maxY", s.maxY);
+			obs_data_set_string(array_obj, "screenRegionStr",
+					    s.regionStr.c_str());
+			obs_data_array_push_back(screenRegionArray, array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "screenRegion", screenRegionArray);
+	obs_data_array_release(screenRegionArray);
+}
+
+void SwitcherData::loadScreenRegionSwitches(obs_data_t *obj)
+{
+	switcher->screenRegionSwitches.clear();
+
+	obs_data_array_t *screenRegionArray =
+		obs_data_get_array(obj, "screenRegion");
+	size_t count = obs_data_array_count(screenRegionArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(screenRegionArray, i);
+
+		const char *scene =
+			obs_data_get_string(array_obj, "screenRegionScene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		int minX = obs_data_get_int(array_obj, "minX");
+		int minY = obs_data_get_int(array_obj, "minY");
+		int maxX = obs_data_get_int(array_obj, "maxX");
+		int maxY = obs_data_get_int(array_obj, "maxY");
+		std::string regionStr =
+			obs_data_get_string(array_obj, "screenRegionStr");
+
+		switcher->screenRegionSwitches.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition), minX, minY, maxX,
+			maxY, regionStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(screenRegionArray);
+}

src/time-switch.cpp

@@ -146,3 +146,69 @@ void SwitcherData::checkTimeSwitch(bool &match, OBSWeakSource &scene,
 		}
 	}
 }
+
+void SwitcherData::saveTimeSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *timeArray = obs_data_array_create();
+	for (TimeSwitch &s : switcher->timeSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *sceneSource = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if ((s.usePreviousScene || sceneSource) && transition) {
+			const char *sceneName =
+				obs_source_get_name(sceneSource);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "scene",
+					    s.usePreviousScene
+						    ? PREVIOUS_SCENE_NAME
+						    : sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(
+				array_obj, "time",
+				s.time.toString().toStdString().c_str());
+			obs_data_array_push_back(timeArray, array_obj);
+		}
+		obs_source_release(sceneSource);
+		obs_source_release(transition);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "timeSwitches", timeArray);
+	obs_data_array_release(timeArray);
+}
+
+void SwitcherData::loadTimeSwitches(obs_data_t *obj)
+{
+	switcher->timeSwitches.clear();
+
+	obs_data_array_t *timeArray = obs_data_get_array(obj, "timeSwitches");
+	size_t count = obs_data_array_count(timeArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj = obs_data_array_item(timeArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		QTime time = QTime::fromString(
+			obs_data_get_string(array_obj, "time"));
+
+		std::string timeSwitchStr =
+			MakeTimeSwitchName(scene, transition, time)
+				.toUtf8()
+				.constData();
+
+		switcher->timeSwitches.emplace_back(
+			GetWeakSourceByName(scene),
+			GetWeakTransitionByName(transition), time,
+			(strcmp(scene, PREVIOUS_SCENE_NAME) == 0),
+			timeSwitchStr);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(timeArray);
+}

src/window-title-switch.cpp

@@ -312,3 +312,93 @@ void SwitcherData::checkWindowTitleSwitch(bool &match, OBSWeakSource &scene,
 		}
 	}
 }
+
+void SwitcherData::saveWindowTitleSwitches(obs_data_t *obj)
+{
+	obs_data_array_t *windowTitleArray = obs_data_array_create();
+	for (WindowSceneSwitch &s : switcher->windowSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+
+		obs_source_t *source = obs_weak_source_get_source(s.scene);
+		obs_source_t *transition =
+			obs_weak_source_get_source(s.transition);
+		if (source && transition) {
+			const char *sceneName = obs_source_get_name(source);
+			const char *transitionName =
+				obs_source_get_name(transition);
+			obs_data_set_string(array_obj, "scene", sceneName);
+			obs_data_set_string(array_obj, "transition",
+					    transitionName);
+			obs_data_set_string(array_obj, "window_title",
+					    s.window.c_str());
+			obs_data_set_bool(array_obj, "fullscreen",
+					  s.fullscreen);
+			obs_data_set_bool(array_obj, "focus", s.focus);
+			obs_data_array_push_back(windowTitleArray, array_obj);
+			obs_source_release(source);
+			obs_source_release(transition);
+		}
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "switches", windowTitleArray);
+	obs_data_array_release(windowTitleArray);
+
+	obs_data_array_t *ignoreWindowsArray = obs_data_array_create();
+	for (std::string &window : switcher->ignoreWindowsSwitches) {
+		obs_data_t *array_obj = obs_data_create();
+		obs_data_set_string(array_obj, "ignoreWindow", window.c_str());
+		obs_data_array_push_back(ignoreWindowsArray, array_obj);
+		obs_data_release(array_obj);
+	}
+	obs_data_set_array(obj, "ignoreWindows", ignoreWindowsArray);
+	obs_data_array_release(ignoreWindowsArray);
+}
+
+void SwitcherData::loadWindowTitleSwitches(obs_data_t *obj)
+{
+	switcher->windowSwitches.clear();
+
+	obs_data_array_t *windowTitleArray =
+		obs_data_get_array(obj, "switches");
+	size_t count = obs_data_array_count(windowTitleArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(windowTitleArray, i);
+
+		const char *scene = obs_data_get_string(array_obj, "scene");
+		const char *transition =
+			obs_data_get_string(array_obj, "transition");
+		const char *window =
+			obs_data_get_string(array_obj, "window_title");
+		bool fullscreen = obs_data_get_bool(array_obj, "fullscreen");
+		bool focus = obs_data_get_bool(array_obj, "focus") ||
+			     !obs_data_has_user_value(array_obj, "focus");
+
+		switcher->windowSwitches.emplace_back(
+			GetWeakSourceByName(scene), window,
+			GetWeakTransitionByName(transition), fullscreen, focus);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(windowTitleArray);
+
+	switcher->ignoreWindowsSwitches.clear();
+
+	obs_data_array_t *ignoreWindowsArray =
+		obs_data_get_array(obj, "ignoreWindows");
+	count = obs_data_array_count(ignoreWindowsArray);
+
+	for (size_t i = 0; i < count; i++) {
+		obs_data_t *array_obj =
+			obs_data_array_item(ignoreWindowsArray, i);
+
+		const char *window =
+			obs_data_get_string(array_obj, "ignoreWindow");
+
+		switcher->ignoreWindowsSwitches.emplace_back(window);
+
+		obs_data_release(array_obj);
+	}
+	obs_data_array_release(ignoreWindowsArray);
+}