clang-format: Increase column limit from 80 to 120

2026-01-22 13:18:34 -05:00 · 2024-10-04 17:33:58 -04:00
parent 109f64c446
commit a1fbf1015f
736 changed files with 22684 additions and 45435 deletions
--- a/UI/api-interface.cpp
+++ b/UI/api-interface.cpp
@@ -28,19 +28,15 @@ template<typename T> struct OBSStudioCallback {
 	T callback;
 	void *private_data;

-	inline OBSStudioCallback(T cb, void *p) : callback(cb), private_data(p)
-	{
-	}
+	inline OBSStudioCallback(T cb, void *p) : callback(cb), private_data(p) {}
 };

 template<typename T>
-inline size_t GetCallbackIdx(vector<OBSStudioCallback<T>> &callbacks,
-			     T callback, void *private_data)
+inline size_t GetCallbackIdx(vector<OBSStudioCallback<T>> &callbacks, T callback, void *private_data)
 {
 	for (size_t i = 0; i < callbacks.size(); i++) {
 		OBSStudioCallback<T> curCB = callbacks[i];
-		if (curCB.callback == callback &&
-		    curCB.private_data == private_data)
+		if (curCB.callback == callback && curCB.private_data == private_data)
 			return i;
 	}

@@ -55,23 +51,13 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 	inline OBSStudioAPI(OBSBasic *main_) : main(main_) {}

-	void *obs_frontend_get_main_window(void) override
-	{
-		return (void *)main;
-	}
+	void *obs_frontend_get_main_window(void) override { return (void *)main; }

-	void *obs_frontend_get_main_window_handle(void) override
-	{
-		return (void *)main->winId();
-	}
+	void *obs_frontend_get_main_window_handle(void) override { return (void *)main->winId(); }

-	void *obs_frontend_get_system_tray(void) override
-	{
-		return (void *)main->trayIcon.data();
-	}
+	void *obs_frontend_get_system_tray(void) override { return (void *)main->trayIcon.data(); }

-	void obs_frontend_get_scenes(
-		struct obs_frontend_source_list *sources) override
+	void obs_frontend_get_scenes(struct obs_frontend_source_list *sources) override
 	{
 		for (int i = 0; i < main->ui->scenes->count(); i++) {
 			QListWidgetItem *item = main->ui->scenes->item(i);
@@ -96,23 +82,18 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 	void obs_frontend_set_current_scene(obs_source_t *scene) override
 	{
 		if (main->IsPreviewProgramMode()) {
-			QMetaObject::invokeMethod(
-				main, "TransitionToScene", WaitConnection(),
-				Q_ARG(OBSSource, OBSSource(scene)));
+			QMetaObject::invokeMethod(main, "TransitionToScene", WaitConnection(),
+						  Q_ARG(OBSSource, OBSSource(scene)));
 		} else {
-			QMetaObject::invokeMethod(
-				main, "SetCurrentScene", WaitConnection(),
-				Q_ARG(OBSSource, OBSSource(scene)),
-				Q_ARG(bool, false));
+			QMetaObject::invokeMethod(main, "SetCurrentScene", WaitConnection(),
+						  Q_ARG(OBSSource, OBSSource(scene)), Q_ARG(bool, false));
 		}
 	}

-	void obs_frontend_get_transitions(
-		struct obs_frontend_source_list *sources) override
+	void obs_frontend_get_transitions(struct obs_frontend_source_list *sources) override
 	{
 		for (int i = 0; i < main->ui->transitions->count(); i++) {
-			OBSSource tr = main->ui->transitions->itemData(i)
-					       .value<OBSSource>();
+			OBSSource tr = main->ui->transitions->itemData(i).value<OBSSource>();

 			if (!tr)
 				continue;
@@ -128,62 +109,43 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return obs_source_get_ref(tr);
 	}

-	void
-	obs_frontend_set_current_transition(obs_source_t *transition) override
+	void obs_frontend_set_current_transition(obs_source_t *transition) override
 	{
-		QMetaObject::invokeMethod(main, "SetTransition",
-					  Q_ARG(OBSSource,
-						OBSSource(transition)));
+		QMetaObject::invokeMethod(main, "SetTransition", Q_ARG(OBSSource, OBSSource(transition)));
 	}

-	int obs_frontend_get_transition_duration(void) override
-	{
-		return main->ui->transitionDuration->value();
-	}
+	int obs_frontend_get_transition_duration(void) override { return main->ui->transitionDuration->value(); }

 	void obs_frontend_set_transition_duration(int duration) override
 	{
-		QMetaObject::invokeMethod(main->ui->transitionDuration,
-					  "setValue", Q_ARG(int, duration));
+		QMetaObject::invokeMethod(main->ui->transitionDuration, "setValue", Q_ARG(int, duration));
 	}

-	void obs_frontend_release_tbar(void) override
-	{
-		QMetaObject::invokeMethod(main, "TBarReleased");
-	}
+	void obs_frontend_release_tbar(void) override { QMetaObject::invokeMethod(main, "TBarReleased"); }

 	void obs_frontend_set_tbar_position(int position) override
 	{
-		QMetaObject::invokeMethod(main, "TBarChanged",
-					  Q_ARG(int, position));
+		QMetaObject::invokeMethod(main, "TBarChanged", Q_ARG(int, position));
 	}

-	int obs_frontend_get_tbar_position(void) override
-	{
-		return main->tBar->value();
-	}
+	int obs_frontend_get_tbar_position(void) override { return main->tBar->value(); }

-	void obs_frontend_get_scene_collections(
-		std::vector<std::string> &strings) override
+	void obs_frontend_get_scene_collections(std::vector<std::string> &strings) override
 	{
-		for (auto &[collectionName, collection] :
-		     main->GetSceneCollectionCache()) {
+		for (auto &[collectionName, collection] : main->GetSceneCollectionCache()) {
 			strings.emplace_back(collectionName);
 		}
 	}

 	char *obs_frontend_get_current_scene_collection(void) override
 	{
-		const OBSSceneCollection &currentCollection =
-			main->GetCurrentSceneCollection();
+		const OBSSceneCollection &currentCollection = main->GetCurrentSceneCollection();
 		return bstrdup(currentCollection.name.c_str());
 	}

-	void obs_frontend_set_current_scene_collection(
-		const char *collection) override
+	void obs_frontend_set_current_scene_collection(const char *collection) override
 	{
-		QList<QAction *> menuActions =
-			main->ui->sceneCollectionMenu->actions();
+		QList<QAction *> menuActions = main->ui->sceneCollectionMenu->actions();
 		QString qstrCollection = QT_UTF8(collection);

 		for (int i = 0; i < menuActions.count(); i++) {
@@ -202,15 +164,12 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 	bool obs_frontend_add_scene_collection(const char *name) override
 	{
 		bool success = false;
-		QMetaObject::invokeMethod(main, "CreateNewSceneCollection",
-					  WaitConnection(),
-					  Q_RETURN_ARG(bool, success),
-					  Q_ARG(QString, QT_UTF8(name)));
+		QMetaObject::invokeMethod(main, "CreateNewSceneCollection", WaitConnection(),
+					  Q_RETURN_ARG(bool, success), Q_ARG(QString, QT_UTF8(name)));
 		return success;
 	}

-	void
-	obs_frontend_get_profiles(std::vector<std::string> &strings) override
+	void obs_frontend_get_profiles(std::vector<std::string> &strings) override
 	{
 		const OBSProfileCache &profiles = main->GetProfileCache();

@@ -252,69 +211,42 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 	void obs_frontend_create_profile(const char *name) override
 	{
-		QMetaObject::invokeMethod(main, "CreateNewProfile",
-					  Q_ARG(QString, name));
+		QMetaObject::invokeMethod(main, "CreateNewProfile", Q_ARG(QString, name));
 	}

 	void obs_frontend_duplicate_profile(const char *name) override
 	{
-		QMetaObject::invokeMethod(main, "CreateDuplicateProfile",
-					  Q_ARG(QString, name));
+		QMetaObject::invokeMethod(main, "CreateDuplicateProfile", Q_ARG(QString, name));
 	}

 	void obs_frontend_delete_profile(const char *profile) override
 	{
-		QMetaObject::invokeMethod(main, "DeleteProfile",
-					  Q_ARG(QString, profile));
+		QMetaObject::invokeMethod(main, "DeleteProfile", Q_ARG(QString, profile));
 	}

-	void obs_frontend_streaming_start(void) override
-	{
-		QMetaObject::invokeMethod(main, "StartStreaming");
-	}
+	void obs_frontend_streaming_start(void) override { QMetaObject::invokeMethod(main, "StartStreaming"); }

-	void obs_frontend_streaming_stop(void) override
-	{
-		QMetaObject::invokeMethod(main, "StopStreaming");
-	}
+	void obs_frontend_streaming_stop(void) override { QMetaObject::invokeMethod(main, "StopStreaming"); }

-	bool obs_frontend_streaming_active(void) override
-	{
-		return os_atomic_load_bool(&streaming_active);
-	}
+	bool obs_frontend_streaming_active(void) override { return os_atomic_load_bool(&streaming_active); }

-	void obs_frontend_recording_start(void) override
-	{
-		QMetaObject::invokeMethod(main, "StartRecording");
-	}
+	void obs_frontend_recording_start(void) override { QMetaObject::invokeMethod(main, "StartRecording"); }

-	void obs_frontend_recording_stop(void) override
-	{
-		QMetaObject::invokeMethod(main, "StopRecording");
-	}
+	void obs_frontend_recording_stop(void) override { QMetaObject::invokeMethod(main, "StopRecording"); }

-	bool obs_frontend_recording_active(void) override
-	{
-		return os_atomic_load_bool(&recording_active);
-	}
+	bool obs_frontend_recording_active(void) override { return os_atomic_load_bool(&recording_active); }

 	void obs_frontend_recording_pause(bool pause) override
 	{
-		QMetaObject::invokeMethod(main, pause ? "PauseRecording"
-						      : "UnpauseRecording");
+		QMetaObject::invokeMethod(main, pause ? "PauseRecording" : "UnpauseRecording");
 	}

-	bool obs_frontend_recording_paused(void) override
-	{
-		return os_atomic_load_bool(&recording_paused);
-	}
+	bool obs_frontend_recording_paused(void) override { return os_atomic_load_bool(&recording_paused); }

 	bool obs_frontend_recording_split_file(void) override
 	{
-		if (os_atomic_load_bool(&recording_active) &&
-		    !os_atomic_load_bool(&recording_paused)) {
-			proc_handler_t *ph = obs_output_get_proc_handler(
-				main->outputHandler->fileOutput);
+		if (os_atomic_load_bool(&recording_active) && !os_atomic_load_bool(&recording_paused)) {
+			proc_handler_t *ph = obs_output_get_proc_handler(main->outputHandler->fileOutput);
 			uint8_t stack[128];
 			calldata cd;
 			calldata_init_fixed(&cd, stack, sizeof(stack));
@@ -328,12 +260,10 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 	bool obs_frontend_recording_add_chapter(const char *name) override
 	{
-		if (!os_atomic_load_bool(&recording_active) ||
-		    os_atomic_load_bool(&recording_paused))
+		if (!os_atomic_load_bool(&recording_active) || os_atomic_load_bool(&recording_paused))
 			return false;

-		proc_handler_t *ph = obs_output_get_proc_handler(
-			main->outputHandler->fileOutput);
+		proc_handler_t *ph = obs_output_get_proc_handler(main->outputHandler->fileOutput);

 		calldata cd;
 		calldata_init(&cd);
@@ -343,25 +273,13 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return result;
 	}

-	void obs_frontend_replay_buffer_start(void) override
-	{
-		QMetaObject::invokeMethod(main, "StartReplayBuffer");
-	}
+	void obs_frontend_replay_buffer_start(void) override { QMetaObject::invokeMethod(main, "StartReplayBuffer"); }

-	void obs_frontend_replay_buffer_save(void) override
-	{
-		QMetaObject::invokeMethod(main, "ReplayBufferSave");
-	}
+	void obs_frontend_replay_buffer_save(void) override { QMetaObject::invokeMethod(main, "ReplayBufferSave"); }

-	void obs_frontend_replay_buffer_stop(void) override
-	{
-		QMetaObject::invokeMethod(main, "StopReplayBuffer");
-	}
+	void obs_frontend_replay_buffer_stop(void) override { QMetaObject::invokeMethod(main, "StopReplayBuffer"); }

-	bool obs_frontend_replay_buffer_active(void) override
-	{
-		return os_atomic_load_bool(&replaybuf_active);
-	}
+	bool obs_frontend_replay_buffer_active(void) override { return os_atomic_load_bool(&replaybuf_active); }

 	void *obs_frontend_add_tools_menu_qaction(const char *name) override
 	{
@@ -369,9 +287,7 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return (void *)main->ui->menuTools->addAction(QT_UTF8(name));
 	}

-	void obs_frontend_add_tools_menu_item(const char *name,
-					      obs_frontend_cb callback,
-					      void *private_data) override
+	void obs_frontend_add_tools_menu_item(const char *name, obs_frontend_cb callback, void *private_data) override
 	{
 		main->ui->menuTools->setEnabled(true);

@@ -389,9 +305,8 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 		QString name = d->objectName();
 		if (name.isEmpty() || main->IsDockObjectNameUsed(name)) {
-			blog(LOG_WARNING,
-			     "The object name of the added dock is empty or already used,"
-			     " a temporary one will be set to avoid conflicts");
+			blog(LOG_WARNING, "The object name of the added dock is empty or already used,"
+					  " a temporary one will be set to avoid conflicts");

 			char *uuid = os_generate_uuid();
 			name = QT_UTF8(uuid);
@@ -404,8 +319,7 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return (void *)main->AddDockWidget(d);
 	}

-	bool obs_frontend_add_dock_by_id(const char *id, const char *title,
-					 void *widget) override
+	bool obs_frontend_add_dock_by_id(const char *id, const char *title, void *widget) override
 	{
 		if (main->IsDockObjectNameUsed(QT_UTF8(id))) {
 			blog(LOG_WARNING,
@@ -428,10 +342,7 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return true;
 	}

-	void obs_frontend_remove_dock(const char *id) override
-	{
-		main->RemoveDockWidget(QT_UTF8(id));
-	}
+	void obs_frontend_remove_dock(const char *id) override { main->RemoveDockWidget(QT_UTF8(id)); }

 	bool obs_frontend_add_custom_qdock(const char *id, void *dock) override
 	{
@@ -451,16 +362,14 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return true;
 	}

-	void obs_frontend_add_event_callback(obs_frontend_event_cb callback,
-					     void *private_data) override
+	void obs_frontend_add_event_callback(obs_frontend_event_cb callback, void *private_data) override
 	{
 		size_t idx = GetCallbackIdx(callbacks, callback, private_data);
 		if (idx == (size_t)-1)
 			callbacks.emplace_back(callback, private_data);
 	}

-	void obs_frontend_remove_event_callback(obs_frontend_event_cb callback,
-						void *private_data) override
+	void obs_frontend_remove_event_callback(obs_frontend_event_cb callback, void *private_data) override
 	{
 		size_t idx = GetCallbackIdx(callbacks, callback, private_data);
 		if (idx == (size_t)-1)
@@ -471,13 +380,8 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 	obs_output_t *obs_frontend_get_streaming_output(void) override
 	{
-		auto multitrackVideo =
-			main->outputHandler->multitrackVideo.get();
-		auto mtvOutput =
-			multitrackVideo
-				? obs_output_get_ref(
-					  multitrackVideo->StreamingOutput())
-				: nullptr;
+		auto multitrackVideo = main->outputHandler->multitrackVideo.get();
+		auto mtvOutput = multitrackVideo ? obs_output_get_ref(multitrackVideo->StreamingOutput()) : nullptr;
 		if (mtvOutput)
 			return mtvOutput;

@@ -497,10 +401,7 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return obs_output_get_ref(out);
 	}

-	config_t *obs_frontend_get_profile_config(void) override
-	{
-		return main->activeConfiguration;
-	}
+	config_t *obs_frontend_get_profile_config(void) override { return main->activeConfiguration; }

 	config_t *obs_frontend_get_global_config(void) override
 	{
@@ -509,19 +410,11 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return App()->GetAppConfig();
 	}

-	config_t *obs_frontend_get_app_config(void) override
-	{
-		return App()->GetAppConfig();
-	}
+	config_t *obs_frontend_get_app_config(void) override { return App()->GetAppConfig(); }

-	config_t *obs_frontend_get_user_config(void) override
-	{
-		return App()->GetUserConfig();
-	}
+	config_t *obs_frontend_get_user_config(void) override { return App()->GetUserConfig(); }

-	void obs_frontend_open_projector(const char *type, int monitor,
-					 const char *geometry,
-					 const char *name) override
+	void obs_frontend_open_projector(const char *type, int monitor, const char *geometry, const char *name) override
 	{
 		SavedProjectorInfo proj = {
 			ProjectorType::Preview,
@@ -539,108 +432,71 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 			else if (astrcmpi(type, "Multiview") == 0)
 				proj.type = ProjectorType::Multiview;
 		}
-		QMetaObject::invokeMethod(main, "OpenSavedProjector",
-					  WaitConnection(),
+		QMetaObject::invokeMethod(main, "OpenSavedProjector", WaitConnection(),
 					  Q_ARG(SavedProjectorInfo *, &proj));
 	}

 	void obs_frontend_save(void) override { main->SaveProject(); }

-	void obs_frontend_defer_save_begin(void) override
-	{
-		QMetaObject::invokeMethod(main, "DeferSaveBegin");
-	}
+	void obs_frontend_defer_save_begin(void) override { QMetaObject::invokeMethod(main, "DeferSaveBegin"); }

-	void obs_frontend_defer_save_end(void) override
-	{
-		QMetaObject::invokeMethod(main, "DeferSaveEnd");
-	}
+	void obs_frontend_defer_save_end(void) override { QMetaObject::invokeMethod(main, "DeferSaveEnd"); }

-	void obs_frontend_add_save_callback(obs_frontend_save_cb callback,
-					    void *private_data) override
+	void obs_frontend_add_save_callback(obs_frontend_save_cb callback, void *private_data) override
 	{
-		size_t idx =
-			GetCallbackIdx(saveCallbacks, callback, private_data);
+		size_t idx = GetCallbackIdx(saveCallbacks, callback, private_data);
 		if (idx == (size_t)-1)
 			saveCallbacks.emplace_back(callback, private_data);
 	}

-	void obs_frontend_remove_save_callback(obs_frontend_save_cb callback,
-					       void *private_data) override
+	void obs_frontend_remove_save_callback(obs_frontend_save_cb callback, void *private_data) override
 	{
-		size_t idx =
-			GetCallbackIdx(saveCallbacks, callback, private_data);
+		size_t idx = GetCallbackIdx(saveCallbacks, callback, private_data);
 		if (idx == (size_t)-1)
 			return;

 		saveCallbacks.erase(saveCallbacks.begin() + idx);
 	}

-	void obs_frontend_add_preload_callback(obs_frontend_save_cb callback,
-					       void *private_data) override
+	void obs_frontend_add_preload_callback(obs_frontend_save_cb callback, void *private_data) override
 	{
-		size_t idx = GetCallbackIdx(preloadCallbacks, callback,
-					    private_data);
+		size_t idx = GetCallbackIdx(preloadCallbacks, callback, private_data);
 		if (idx == (size_t)-1)
 			preloadCallbacks.emplace_back(callback, private_data);
 	}

-	void obs_frontend_remove_preload_callback(obs_frontend_save_cb callback,
-						  void *private_data) override
+	void obs_frontend_remove_preload_callback(obs_frontend_save_cb callback, void *private_data) override
 	{
-		size_t idx = GetCallbackIdx(preloadCallbacks, callback,
-					    private_data);
+		size_t idx = GetCallbackIdx(preloadCallbacks, callback, private_data);
 		if (idx == (size_t)-1)
 			return;

 		preloadCallbacks.erase(preloadCallbacks.begin() + idx);
 	}

-	void obs_frontend_push_ui_translation(
-		obs_frontend_translate_ui_cb translate) override
+	void obs_frontend_push_ui_translation(obs_frontend_translate_ui_cb translate) override
 	{
 		App()->PushUITranslation(translate);
 	}

-	void obs_frontend_pop_ui_translation(void) override
-	{
-		App()->PopUITranslation();
-	}
+	void obs_frontend_pop_ui_translation(void) override { App()->PopUITranslation(); }

-	void obs_frontend_set_streaming_service(obs_service_t *service) override
-	{
-		main->SetService(service);
-	}
+	void obs_frontend_set_streaming_service(obs_service_t *service) override { main->SetService(service); }

-	obs_service_t *obs_frontend_get_streaming_service(void) override
-	{
-		return main->GetService();
-	}
+	obs_service_t *obs_frontend_get_streaming_service(void) override { return main->GetService(); }

-	void obs_frontend_save_streaming_service(void) override
-	{
-		main->SaveService();
-	}
+	void obs_frontend_save_streaming_service(void) override { main->SaveService(); }

-	bool obs_frontend_preview_program_mode_active(void) override
-	{
-		return main->IsPreviewProgramMode();
-	}
+	bool obs_frontend_preview_program_mode_active(void) override { return main->IsPreviewProgramMode(); }

-	void obs_frontend_set_preview_program_mode(bool enable) override
-	{
-		main->SetPreviewProgramMode(enable);
-	}
+	void obs_frontend_set_preview_program_mode(bool enable) override { main->SetPreviewProgramMode(enable); }

 	void obs_frontend_preview_program_trigger_transition(void) override
 	{
 		QMetaObject::invokeMethod(main, "TransitionClicked");
 	}

-	bool obs_frontend_preview_enabled(void) override
-	{
-		return main->previewEnabled;
-	}
+	bool obs_frontend_preview_enabled(void) override { return main->previewEnabled; }

 	void obs_frontend_set_preview_enabled(bool enable) override
 	{
@@ -658,26 +514,19 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return nullptr;
 	}

-	void
-	obs_frontend_set_current_preview_scene(obs_source_t *scene) override
+	void obs_frontend_set_current_preview_scene(obs_source_t *scene) override
 	{
 		if (main->IsPreviewProgramMode()) {
-			QMetaObject::invokeMethod(main, "SetCurrentScene",
-						  Q_ARG(OBSSource,
-							OBSSource(scene)),
+			QMetaObject::invokeMethod(main, "SetCurrentScene", Q_ARG(OBSSource, OBSSource(scene)),
 						  Q_ARG(bool, false));
 		}
 	}

-	void obs_frontend_take_screenshot(void) override
-	{
-		QMetaObject::invokeMethod(main, "Screenshot");
-	}
+	void obs_frontend_take_screenshot(void) override { QMetaObject::invokeMethod(main, "Screenshot"); }

 	void obs_frontend_take_source_screenshot(obs_source_t *source) override
 	{
-		QMetaObject::invokeMethod(main, "Screenshot",
-					  Q_ARG(OBSSource, OBSSource(source)));
+		QMetaObject::invokeMethod(main, "Screenshot", Q_ARG(OBSSource, OBSSource(source)));
 	}

 	obs_output_t *obs_frontend_get_virtualcam_output(void) override
@@ -686,47 +535,32 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return obs_output_get_ref(output);
 	}

-	void obs_frontend_start_virtualcam(void) override
-	{
-		QMetaObject::invokeMethod(main, "StartVirtualCam");
-	}
+	void obs_frontend_start_virtualcam(void) override { QMetaObject::invokeMethod(main, "StartVirtualCam"); }

-	void obs_frontend_stop_virtualcam(void) override
-	{
-		QMetaObject::invokeMethod(main, "StopVirtualCam");
-	}
+	void obs_frontend_stop_virtualcam(void) override { QMetaObject::invokeMethod(main, "StopVirtualCam"); }

-	bool obs_frontend_virtualcam_active(void) override
-	{
-		return os_atomic_load_bool(&virtualcam_active);
-	}
+	bool obs_frontend_virtualcam_active(void) override { return os_atomic_load_bool(&virtualcam_active); }

 	void obs_frontend_reset_video(void) override { main->ResetVideo(); }

 	void obs_frontend_open_source_properties(obs_source_t *source) override
 	{
-		QMetaObject::invokeMethod(main, "OpenProperties",
-					  Q_ARG(OBSSource, OBSSource(source)));
+		QMetaObject::invokeMethod(main, "OpenProperties", Q_ARG(OBSSource, OBSSource(source)));
 	}

 	void obs_frontend_open_source_filters(obs_source_t *source) override
 	{
-		QMetaObject::invokeMethod(main, "OpenFilters",
-					  Q_ARG(OBSSource, OBSSource(source)));
+		QMetaObject::invokeMethod(main, "OpenFilters", Q_ARG(OBSSource, OBSSource(source)));
 	}

 	void obs_frontend_open_source_interaction(obs_source_t *source) override
 	{
-		QMetaObject::invokeMethod(main, "OpenInteraction",
-					  Q_ARG(OBSSource, OBSSource(source)));
+		QMetaObject::invokeMethod(main, "OpenInteraction", Q_ARG(OBSSource, OBSSource(source)));
 	}

-	void obs_frontend_open_sceneitem_edit_transform(
-		obs_sceneitem_t *item) override
+	void obs_frontend_open_sceneitem_edit_transform(obs_sceneitem_t *item) override
 	{
-		QMetaObject::invokeMethod(main, "OpenEditTransform",
-					  Q_ARG(OBSSceneItem,
-						OBSSceneItem(item)));
+		QMetaObject::invokeMethod(main, "OpenEditTransform", Q_ARG(OBSSceneItem, OBSSceneItem(item)));
 	}

 	char *obs_frontend_get_current_record_output_path(void) override
@@ -736,43 +570,25 @@ struct OBSStudioAPI : obs_frontend_callbacks {
 		return bstrdup(recordOutputPath);
 	}

-	const char *obs_frontend_get_locale_string(const char *string) override
-	{
-		return Str(string);
-	}
+	const char *obs_frontend_get_locale_string(const char *string) override { return Str(string); }

-	bool obs_frontend_is_theme_dark(void) override
-	{
-		return App()->IsThemeDark();
-	}
+	bool obs_frontend_is_theme_dark(void) override { return App()->IsThemeDark(); }

 	char *obs_frontend_get_last_recording(void) override
 	{
 		return bstrdup(main->outputHandler->lastRecordingPath.c_str());
 	}

-	char *obs_frontend_get_last_screenshot(void) override
-	{
-		return bstrdup(main->lastScreenshot.c_str());
-	}
+	char *obs_frontend_get_last_screenshot(void) override { return bstrdup(main->lastScreenshot.c_str()); }

-	char *obs_frontend_get_last_replay(void) override
-	{
-		return bstrdup(main->lastReplay.c_str());
-	}
+	char *obs_frontend_get_last_replay(void) override { return bstrdup(main->lastReplay.c_str()); }

-	void obs_frontend_add_undo_redo_action(const char *name,
-					       const undo_redo_cb undo,
-					       const undo_redo_cb redo,
-					       const char *undo_data,
-					       const char *redo_data,
-					       bool repeatable) override
+	void obs_frontend_add_undo_redo_action(const char *name, const undo_redo_cb undo, const undo_redo_cb redo,
+					       const char *undo_data, const char *redo_data, bool repeatable) override
 	{
 		main->undo_s.add_action(
-			name,
-			[undo](const std::string &data) { undo(data.c_str()); },
-			[redo](const std::string &data) { redo(data.c_str()); },
-			undo_data, redo_data, repeatable);
+			name, [undo](const std::string &data) { undo(data.c_str()); },
+			[redo](const std::string &data) { redo(data.c_str()); }, undo_data, redo_data, repeatable);
 	}

 	void on_load(obs_data_t *settings) override
@@ -801,8 +617,7 @@ struct OBSStudioAPI : obs_frontend_callbacks {

 	void on_event(enum obs_frontend_event event) override
 	{
-		if (main->disableSaving &&
-		    event != OBS_FRONTEND_EVENT_SCENE_COLLECTION_CLEANUP &&
+		if (main->disableSaving && event != OBS_FRONTEND_EVENT_SCENE_COLLECTION_CLEANUP &&
 		    event != OBS_FRONTEND_EVENT_EXIT)
 			return;