requesthandler: Add Canvas support

CMakeLists.txt

@@ -61,6 +61,7 @@ target_sources(
   PRIVATE # cmake-format: sortable
           src/eventhandler/EventHandler.cpp
           src/eventhandler/EventHandler.h
+          src/eventhandler/EventHandler_Canvases.cpp
           src/eventhandler/EventHandler_Config.cpp
           src/eventhandler/EventHandler_Filters.cpp
           src/eventhandler/EventHandler_General.cpp
@@ -80,6 +81,7 @@ target_sources(
           src/requesthandler/RequestBatchHandler.h
           src/requesthandler/RequestHandler.cpp
           src/requesthandler/RequestHandler.h
+          src/requesthandler/RequestHandler_Canvases.cpp
           src/requesthandler/RequestHandler_Config.cpp
           src/requesthandler/RequestHandler_Filters.cpp
           src/requesthandler/RequestHandler_General.cpp

docs/docs/generate_md.py

@@ -18,6 +18,7 @@
     'General',
     'Config',
     'Sources',
+    'Canvas',
     'Scenes',
     'Inputs',
     'Transitions',

src/eventhandler/EventHandler.cpp

@@ -28,10 +28,15 @@ EventHandler::EventHandler()
 	signal_handler_t *coreSignalHandler = obs_get_signal_handler();
 	if (coreSignalHandler) {
 		coreSignals.emplace_back(coreSignalHandler, "source_create", SourceCreatedMultiHandler, this);
+		coreSignals.emplace_back(coreSignalHandler, "source_create_canvas", SourceCreatedMultiHandler, this);
 		coreSignals.emplace_back(coreSignalHandler, "source_destroy", SourceDestroyedMultiHandler, this);
 		coreSignals.emplace_back(coreSignalHandler, "source_remove", SourceRemovedMultiHandler, this);
 		coreSignals.emplace_back(coreSignalHandler, "source_rename", SourceRenamedMultiHandler, this);
 		coreSignals.emplace_back(coreSignalHandler, "source_update", SourceUpdatedMultiHandler, this);
+		coreSignals.emplace_back(coreSignalHandler, "canvas_create", CanvasCreatedMultiHandler, this);
+		coreSignals.emplace_back(coreSignalHandler, "canvas_destroy", CanvasDestroyedMultiHandler, this);
+		coreSignals.emplace_back(coreSignalHandler, "canvas_remove", CanvasRemovedMultiHandler, this);
+		coreSignals.emplace_back(coreSignalHandler, "canvas_rename", CanvasRenamedMultiHandler, this);
 	} else {
 		blog(LOG_ERROR, "[EventHandler::EventHandler] Unable to get libobs signal handler!");
 	}
@@ -599,6 +604,58 @@ void EventHandler::SourceUpdatedMultiHandler(void *param, calldata_t *data)
 	}
 }
 
+void EventHandler::CanvasCreatedMultiHandler(void *param, calldata_t *data)
+{
+	auto eventHandler = static_cast<EventHandler *>(param);
+	obs_canvas_t *canvas = GetCalldataPointer<obs_canvas_t>(data, "canvas");
+	if (!canvas)
+		return;
+
+	signal_handler_t *sh = obs_canvas_get_signal_handler(canvas);
+	signal_handler_connect(sh, "source_rename", SourceRenamedMultiHandler, eventHandler);
+
+	eventHandler->HandleCanvasCreated(canvas);
+}
+
+void EventHandler::CanvasDestroyedMultiHandler(void *param, calldata_t *data)
+{
+	auto eventHandler = static_cast<EventHandler *>(param);
+	obs_canvas_t *canvas = GetCalldataPointer<obs_canvas_t>(data, "canvas");
+	if (!canvas)
+		return;
+
+	if (!obs_canvas_removed(canvas))
+		eventHandler->HandleCanvasRemoved(canvas);
+}
+
+void EventHandler::CanvasRemovedMultiHandler(void *param, calldata_t *data)
+{
+	auto eventHandler = static_cast<EventHandler *>(param);
+	obs_canvas_t *canvas = GetCalldataPointer<obs_canvas_t>(data, "canvas");
+	if (!canvas)
+		return;
+
+	signal_handler_t *sh = obs_canvas_get_signal_handler(canvas);
+	signal_handler_disconnect(sh, "source_rename", SourceRenamedMultiHandler, eventHandler);
+
+	eventHandler->HandleCanvasRemoved(canvas);
+}
+
+void EventHandler::CanvasRenamedMultiHandler(void *param, calldata_t *data)
+{
+	auto eventHandler = static_cast<EventHandler *>(param);
+	obs_canvas_t *canvas = GetCalldataPointer<obs_canvas_t>(data, "canvas");
+	if (!canvas)
+		return;
+
+	std::string oldCanvasName = calldata_string(data, "prev_name");
+	std::string canvasName = calldata_string(data, "new_name");
+	if (oldCanvasName.empty() || canvasName.empty())
+		return;
+
+	eventHandler->HandleCanvasNameChanged(canvas, oldCanvasName, canvasName);
+}
+
 void EventHandler::StreamOutputReconnectHandler(void *param, calldata_t *)
 {
 	auto eventHandler = static_cast<EventHandler *>(param);

src/eventhandler/EventHandler.h

@@ -76,6 +76,10 @@ class EventHandler {
 	static void SourceRemovedMultiHandler(void *param, calldata_t *data);
 	static void SourceRenamedMultiHandler(void *param, calldata_t *data);
 	static void SourceUpdatedMultiHandler(void *param, calldata_t *data);
+	static void CanvasCreatedMultiHandler(void *param, calldata_t *data);
+	static void CanvasDestroyedMultiHandler(void *param, calldata_t *data);
+	static void CanvasRemovedMultiHandler(void *param, calldata_t *data);
+	static void CanvasRenamedMultiHandler(void *param, calldata_t *data);
 
 	// Signal handler: media sources
 	static void SourceMediaPauseMultiHandler(void *param, calldata_t *data);
@@ -100,6 +104,11 @@ class EventHandler {
 	void HandleCurrentProfileChanged();
 	void HandleProfileListChanged();
 
+	// Canvases
+	void HandleCanvasCreated(obs_canvas_t *canvas);
+	void HandleCanvasRemoved(obs_canvas_t *canvas);
+	void HandleCanvasNameChanged(obs_canvas_t *canvas, std::string oldCanvasName, std::string canvasName);
+
 	// Scenes
 	void HandleSceneCreated(obs_source_t *source);
 	void HandleSceneRemoved(obs_source_t *source);

src/eventhandler/EventHandler_Canvases.cpp

@@ -0,0 +1,88 @@
+/*
+obs-websocket
+Copyright (C) 2016-2021 Stephane Lepin <stephane.lepin@gmail.com>
+Copyright (C) 2020-2021 Kyle Manning <tt2468@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program. If not, see <https://www.gnu.org/licenses/>
+*/
+
+#include "EventHandler.h"
+
+/**
+ * A new canvas has been created.
+ *
+ * @dataField canvasName | String  | Name of the new canvas
+ * @dataField canvasUuid | String  | UUID of the new canvas
+ *
+ * @eventType CanvasCreated
+ * @eventSubscription Canvases
+ * @complexity 2
+ * @rpcVersion -1
+ * @initialVersion 5.7.0
+ * @api events
+ * @category canvas
+ */
+void EventHandler::HandleCanvasCreated(obs_canvas_t *canvas)
+{
+	json eventData;
+	eventData["canvasName"] = obs_canvas_get_name(canvas);
+	eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	BroadcastEvent(EventSubscription::Canvases, "CanvasCreated", eventData);
+}
+
+/**
+ * A canvas has been removed.
+ *
+ * @dataField canvasName | String  | Name of the removed canvas
+ * @dataField canvasUuid | String  | UUID of the removed canvas
+ *
+ * @eventType CanvasRemoved
+ * @eventSubscription Canvases
+ * @complexity 2
+ * @rpcVersion -1
+ * @initialVersion 5.7.0
+ * @api events
+ * @category canvas
+ */
+void EventHandler::HandleCanvasRemoved(obs_canvas_t *canvas)
+{
+	json eventData;
+	eventData["canvasName"] = obs_canvas_get_name(canvas);
+	eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	BroadcastEvent(EventSubscription::Canvases, "CanvasRemoved", eventData);
+}
+
+/**
+ * The name of a canvas has changed.
+ *
+ * @dataField canvasUuid    | String | UUID of the canvas
+ * @dataField oldCanvasName | String | Old name of the canvas
+ * @dataField canvasName    | String | New name of the canvas
+ *
+ * @eventType CanvasNameChanged
+ * @eventSubscription Canvases
+ * @complexity 2
+ * @rpcVersion -1
+ * @initialVersion 5.7.0
+ * @api events
+ * @category canvas
+ */
+void EventHandler::HandleCanvasNameChanged(obs_canvas_t *canvas, std::string oldCanvasName, std::string canvasName)
+{
+	json eventData;
+	eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	eventData["oldCanvasName"] = oldCanvasName;
+	eventData["canvasName"] = canvasName;
+	BroadcastEvent(EventSubscription::Canvases, "CanvasNameChanged", eventData);
+}

src/eventhandler/EventHandler_SceneItems.cpp

@@ -56,6 +56,11 @@ void EventHandler::HandleSceneItemCreated(void *param, calldata_t *data)
 	eventData["sourceUuid"] = obs_source_get_uuid(obs_sceneitem_get_source(sceneItem));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
 	eventData["sceneItemIndex"] = obs_sceneitem_get_order_position(sceneItem);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemCreated", eventData);
 }
 
@@ -96,6 +101,11 @@ void EventHandler::HandleSceneItemRemoved(void *param, calldata_t *data)
 	eventData["sourceName"] = obs_source_get_name(obs_sceneitem_get_source(sceneItem));
 	eventData["sourceUuid"] = obs_source_get_uuid(obs_sceneitem_get_source(sceneItem));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemRemoved", eventData);
 }
 
@@ -126,6 +136,11 @@ void EventHandler::HandleSceneItemListReindexed(void *param, calldata_t *data)
 	eventData["sceneName"] = obs_source_get_name(obs_scene_get_source(scene));
 	eventData["sceneUuid"] = obs_source_get_uuid(obs_scene_get_source(scene));
 	eventData["sceneItems"] = Utils::Obs::ArrayHelper::GetSceneItemList(scene, true);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemListReindexed", eventData);
 }
 
@@ -164,6 +179,11 @@ void EventHandler::HandleSceneItemEnableStateChanged(void *param, calldata_t *da
 	eventData["sceneUuid"] = obs_source_get_uuid(obs_scene_get_source(scene));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
 	eventData["sceneItemEnabled"] = sceneItemEnabled;
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemEnableStateChanged", eventData);
 }
 
@@ -202,6 +222,11 @@ void EventHandler::HandleSceneItemLockStateChanged(void *param, calldata_t *data
 	eventData["sceneUuid"] = obs_source_get_uuid(obs_scene_get_source(scene));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
 	eventData["sceneItemLocked"] = sceneItemLocked;
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemLockStateChanged", eventData);
 }
 
@@ -236,6 +261,11 @@ void EventHandler::HandleSceneItemSelected(void *param, calldata_t *data)
 	eventData["sceneName"] = obs_source_get_name(obs_scene_get_source(scene));
 	eventData["sceneUuid"] = obs_source_get_uuid(obs_scene_get_source(scene));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItems, "SceneItemSelected", eventData);
 }
 
@@ -275,5 +305,10 @@ void EventHandler::HandleSceneItemTransformChanged(void *param, calldata_t *data
 	eventData["sceneUuid"] = obs_source_get_uuid(obs_scene_get_source(scene));
 	eventData["sceneItemId"] = obs_sceneitem_get_id(sceneItem);
 	eventData["sceneItemTransform"] = Utils::Obs::ObjectHelper::GetSceneItemTransform(sceneItem);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(obs_scene_get_source(scene));
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	eventHandler->BroadcastEvent(EventSubscription::SceneItemTransformChanged, "SceneItemTransformChanged", eventData);
 }

src/eventhandler/EventHandler_Scenes.cpp

@@ -40,6 +40,11 @@ void EventHandler::HandleSceneCreated(obs_source_t *source)
 	eventData["sceneName"] = obs_source_get_name(source);
 	eventData["sceneUuid"] = obs_source_get_uuid(source);
 	eventData["isGroup"] = obs_source_is_group(source);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(source);
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	BroadcastEvent(EventSubscription::Scenes, "SceneCreated", eventData);
 }
 
@@ -64,6 +69,11 @@ void EventHandler::HandleSceneRemoved(obs_source_t *source)
 	eventData["sceneName"] = obs_source_get_name(source);
 	eventData["sceneUuid"] = obs_source_get_uuid(source);
 	eventData["isGroup"] = obs_source_is_group(source);
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(source);
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	BroadcastEvent(EventSubscription::Scenes, "SceneRemoved", eventData);
 }
 
@@ -88,6 +98,11 @@ void EventHandler::HandleSceneNameChanged(obs_source_t *source, std::string oldS
 	eventData["sceneUuid"] = obs_source_get_uuid(source);
 	eventData["oldSceneName"] = oldSceneName;
 	eventData["sceneName"] = sceneName;
+	OBSCanvasAutoRelease canvas = obs_source_get_canvas(source);
+	if (canvas) {
+		eventData["canvasName"] = obs_canvas_get_name(canvas);
+		eventData["canvasUuid"] = obs_canvas_get_uuid(canvas);
+	}
 	BroadcastEvent(EventSubscription::Scenes, "SceneNameChanged", eventData);
 }
 

src/eventhandler/types/EventSubscription.h

@@ -154,17 +154,28 @@ namespace EventSubscription {
 		*/
 		Ui = (1 << 10),
 		/**
+		* Subscription value to receive events in the `Canvases` category.
+		*
+		* @enumIdentifier Canvases
+		* @enumValue (1 << 11)
+		* @enumType EventSubscription
+		* @rpcVersion -1
+		* @initialVersion 5.7.0
+		* @api enums
+		*/
+		Canvases = (1 << 11),
+		/**
 		* Helper to receive all non-high-volume events.
 		*
 		* @enumIdentifier All
-		* @enumValue (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors | Ui)
+		* @enumValue (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors | Ui | Canvases)
 		* @enumType EventSubscription
 		* @rpcVersion -1
 		* @initialVersion 5.0.0
 		* @api enums
 		*/
 		All = (General | Config | Scenes | Inputs | Transitions | Filters | Outputs | SceneItems | MediaInputs | Vendors |
-		       Ui),
+		       Ui | Canvases),
 		/**
 		* Subscription value to receive the `InputVolumeMeters` high-volume event.
 		*

src/requesthandler/RequestHandler.cpp

@@ -53,6 +53,9 @@ const std::unordered_map<std::string, RequestMethodHandler> RequestHandler::_han
 	{"GetRecordDirectory", &RequestHandler::GetRecordDirectory},
 	{"SetRecordDirectory", &RequestHandler::SetRecordDirectory},
 
+	// Canvases
+	{"GetCanvasList", &RequestHandler::GetCanvasList},
+
 	// Sources
 	{"GetSourceActive", &RequestHandler::GetSourceActive},
 	{"GetSourceScreenshot", &RequestHandler::GetSourceScreenshot},

src/requesthandler/RequestHandler.h

@@ -72,6 +72,9 @@ class RequestHandler {
 	RequestResult GetRecordDirectory(const Request &);
 	RequestResult SetRecordDirectory(const Request &);
 
+	// Canvases
+	RequestResult GetCanvasList(const Request &);
+
 	// Sources
 	RequestResult GetSourceActive(const Request &);
 	RequestResult GetSourceScreenshot(const Request &);