feat: add missing canvas UUID fields

Author: dnaka91

examples/screenshot.rs

@@ -16,6 +16,7 @@ async fn main() -> Result<()> {
         .sources()
         .take_screenshot(TakeScreenshot {
             source: "OBWS-TEST-Scene".into(),
+            canvas: None,
             width: None,
             height: None,
             compression_quality: None,

src/client/filters.rs

@@ -1,12 +1,13 @@
 use serde::{Serialize, de::DeserializeOwned};
+use uuid::Uuid;
 
 use super::Client;
 use crate::{
     error::Result,
     requests::{
         filters::{
-            Create, CreateInternal, Request, SetEnabled, SetIndex, SetName, SetSettings,
-            SetSettingsInternal,
+            Create, CreateInternal, Get, Remove, Request, SetEnabled, SetIndex, SetName,
+            SetSettings, SetSettingsInternal,
         },
         sources::SourceId,
     },
@@ -30,9 +31,13 @@ impl Filters<'_> {
 
     /// Gets an array of all of a source's filters.
     #[doc(alias = "GetSourceFilterList")]
-    pub async fn list(&self, source: SourceId<'_>) -> Result<Vec<responses::SourceFilter>> {
+    pub async fn list(
+        &self,
+        canvas: Option<Uuid>,
+        source: SourceId<'_>,
+    ) -> Result<Vec<responses::SourceFilter>> {
         self.client
-            .send_message::<_, responses::Filters>(Request::List { source })
+            .send_message::<_, responses::Filters>(Request::List { canvas, source })
             .await
             .map(|f| f.filters)
     }
@@ -60,6 +65,7 @@ impl Filters<'_> {
         self.client
             .send_message(Request::Create(CreateInternal {
                 source: filter.source,
+                canvas: filter.canvas,
                 filter: filter.filter,
                 kind: filter.kind,
                 settings: filter
@@ -73,10 +79,8 @@ impl Filters<'_> {
 
     /// Removes a filter from a source.
     #[doc(alias = "RemoveSourceFilter")]
-    pub async fn remove(&self, source: SourceId<'_>, filter: &str) -> Result<()> {
-        self.client
-            .send_message(Request::Remove { source, filter })
-            .await
+    pub async fn remove(&self, filter: Remove<'_>) -> Result<()> {
+        self.client.send_message(Request::Remove(filter)).await
     }
 
     /// Sets the name of a source filter (rename).
@@ -87,10 +91,8 @@ impl Filters<'_> {
 
     /// Gets the info for a specific source filter.
     #[doc(alias = "GetSourceFilter")]
-    pub async fn get(&self, source: SourceId<'_>, filter: &str) -> Result<responses::SourceFilter> {
-        self.client
-            .send_message(Request::Get { source, filter })
-            .await
+    pub async fn get(&self, filter: Get<'_>) -> Result<responses::SourceFilter> {
+        self.client.send_message(Request::Get(filter)).await
     }
 
     /// Sets the index position of a filter on a source.
@@ -108,6 +110,7 @@ impl Filters<'_> {
         self.client
             .send_message(Request::SetSettings(SetSettingsInternal {
                 source: settings.source,
+                canvas: settings.canvas,
                 filter: settings.filter,
                 settings: serde_json::to_value(&settings.settings)
                     .map_err(crate::error::SerializeCustomDataError)?,

src/client/inputs.rs

@@ -139,6 +139,7 @@ impl Inputs<'_> {
     {
         self.client
             .send_message(Request::Create(CreateInputInternal {
+                canvas: input.canvas,
                 scene: input.scene,
                 input: input.input,
                 kind: input.kind,

src/client/scene_items.rs

@@ -1,13 +1,15 @@
 use serde::{Serialize, de::DeserializeOwned};
+use uuid::Uuid;
 
 use super::Client;
 use crate::{
-    common::BlendMode,
+    common,
     error::Result,
     requests::{
         scene_items::{
-            CreateSceneItem, Duplicate, Id, Request, SetBlendMode, SetEnabled, SetIndex, SetLocked,
-            SetPrivateSettings, SetPrivateSettingsInternal, SetTransform, Source,
+            BlendMode, CreateSceneItem, Duplicate, Enabled, Id, Index, Locked, Remove, Request,
+            SetBlendMode, SetEnabled, SetIndex, SetLocked, SetPrivateSettings,
+            SetPrivateSettingsInternal, SetTransform, Source, Transform,
         },
         scenes::SceneId,
     },
@@ -22,9 +24,13 @@ pub struct SceneItems<'a> {
 impl<'a> SceneItems<'a> {
     /// Gets a list of all scene items in a scene.
     #[doc(alias = "GetSceneItemList")]
-    pub async fn list(&self, scene: SceneId<'_>) -> Result<Vec<responses::SceneItem>> {
+    pub async fn list(
+        &self,
+        canvas: Option<Uuid>,
+        scene: SceneId<'_>,
+    ) -> Result<Vec<responses::SceneItem>> {
         self.client
-            .send_message::<_, responses::SceneItemList>(Request::List { scene })
+            .send_message::<_, responses::SceneItemList>(Request::List { canvas, scene })
             .await
             .map(|sil| sil.scene_items)
     }
@@ -33,9 +39,13 @@ impl<'a> SceneItems<'a> {
     ///
     /// Using groups at all in OBS is discouraged, as they are very broken under the hood.
     #[doc(alias = "GetGroupSceneItemList")]
-    pub async fn list_group(&self, scene: SceneId<'_>) -> Result<Vec<responses::SceneItem>> {
+    pub async fn list_group(
+        &self,
+        canvas: Option<Uuid>,
+        scene: SceneId<'_>,
+    ) -> Result<Vec<responses::SceneItem>> {
         self.client
-            .send_message::<_, responses::SceneItemList>(Request::ListGroup { scene })
+            .send_message::<_, responses::SceneItemList>(Request::ListGroup { canvas, scene })
             .await
             .map(|sil| sil.scene_items)
     }
@@ -66,10 +76,8 @@ impl<'a> SceneItems<'a> {
 
     /// Removes a scene item from a scene.
     #[doc(alias = "RemoveSceneItem")]
-    pub async fn remove(&self, scene: SceneId<'_>, item_id: i64) -> Result<()> {
-        self.client
-            .send_message(Request::Remove { scene, item_id })
-            .await
+    pub async fn remove(&self, remove: Remove<'_>) -> Result<()> {
+        self.client.send_message(Request::Remove(remove)).await
     }
 
     /// Duplicates a scene item, copying all transform and crop info.
@@ -85,14 +93,10 @@ impl<'a> SceneItems<'a> {
     #[doc(alias = "GetSceneItemTransform")]
     pub async fn transform(
         &self,
-        scene: SceneId<'_>,
-        item_id: i64,
+        transform: Transform<'_>,
     ) -> Result<responses::SceneItemTransform> {
         self.client
-            .send_message::<_, responses::GetSceneItemTransform>(Request::Transform {
-                scene,
-                item_id,
-            })
+            .send_message::<_, responses::GetSceneItemTransform>(Request::Transform(transform))
             .await
             .map(|gsit| gsit.transform)
     }
@@ -107,9 +111,9 @@ impl<'a> SceneItems<'a> {
 
     /// Gets the enable state of a scene item.
     #[doc(alias = "GetSceneItemEnabled")]
-    pub async fn enabled(&self, scene: SceneId<'_>, item_id: i64) -> Result<bool> {
+    pub async fn enabled(&self, enabled: Enabled<'a>) -> Result<bool> {
         self.client
-            .send_message::<_, responses::SceneItemEnabled>(Request::Enabled { scene, item_id })
+            .send_message::<_, responses::SceneItemEnabled>(Request::Enabled(enabled))
             .await
             .map(|sie| sie.enabled)
     }
@@ -122,9 +126,9 @@ impl<'a> SceneItems<'a> {
 
     /// Gets the lock state of a scene item.
     #[doc(alias = "GetSceneItemLocked")]
-    pub async fn locked(&self, scene: SceneId<'_>, item_id: i64) -> Result<bool> {
+    pub async fn locked(&self, locked: Locked<'a>) -> Result<bool> {
         self.client
-            .send_message::<_, responses::SceneItemLocked>(Request::Locked { scene, item_id })
+            .send_message::<_, responses::SceneItemLocked>(Request::Locked(locked))
             .await
             .map(|sil| sil.locked)
     }
@@ -139,9 +143,9 @@ impl<'a> SceneItems<'a> {
     ///
     /// An index of 0 is at the bottom of the source list in the UI.
     #[doc(alias = "GetSceneItemIndex")]
-    pub async fn index(&self, scene: SceneId<'_>, item_id: i64) -> Result<u32> {
+    pub async fn index(&self, index: Index<'a>) -> Result<u32> {
         self.client
-            .send_message::<_, responses::SceneItemIndex>(Request::Index { scene, item_id })
+            .send_message::<_, responses::SceneItemIndex>(Request::Index(index))
             .await
             .map(|sii| sii.index)
     }
@@ -154,9 +158,9 @@ impl<'a> SceneItems<'a> {
 
     /// Gets the blend mode of a scene item.
     #[doc(alias = "GetSceneItemBlendMode")]
-    pub async fn blend_mode(&self, scene: SceneId<'_>, item_id: i64) -> Result<BlendMode> {
+    pub async fn blend_mode(&self, mode: BlendMode<'_>) -> Result<common::BlendMode> {
         self.client
-            .send_message::<_, responses::SceneItemBlendMode>(Request::BlendMode { scene, item_id })
+            .send_message::<_, responses::SceneItemBlendMode>(Request::BlendMode(mode))
             .await
             .map(|sibm| sibm.blend_mode)
     }

src/client/scenes.rs

@@ -3,7 +3,7 @@ use uuid::Uuid;
 use super::Client;
 use crate::{
     error::Result,
-    requests::scenes::{Request, SceneId, SetTransitionOverride},
+    requests::scenes::{Request, SceneId, SetName, SetTransitionOverride},
     responses::scenes as responses,
 };
 
@@ -32,6 +32,9 @@ impl Scenes<'_> {
     }
 
     /// Gets the current program scene.
+    ///
+    /// **Note:** Canvases do not have any concept of a program or preview scene, so this request
+    /// does not support canvases.
     #[doc(alias = "GetCurrentProgramScene")]
     pub async fn current_program_scene(&self) -> Result<responses::CurrentProgramScene> {
         self.client.send_message(Request::CurrentProgramScene).await
@@ -69,35 +72,36 @@ impl Scenes<'_> {
 
     /// Sets the name of a scene (rename).
     #[doc(alias = "SetSceneName")]
-    pub async fn set_name(&self, scene: SceneId<'_>, new_name: &str) -> Result<()> {
-        self.client
-            .send_message(Request::SetName { scene, new_name })
-            .await
+    pub async fn set_name(&self, name: SetName<'_>) -> Result<()> {
+        self.client.send_message(Request::SetName(name)).await
     }
 
     /// Creates a new scene in OBS.
     #[doc(alias = "CreateScene")]
-    pub async fn create(&self, name: &str) -> Result<Uuid> {
+    pub async fn create(&self, canvas: Option<Uuid>, name: &str) -> Result<Uuid> {
         self.client
-            .send_message::<_, responses::CreateScene>(Request::Create { name })
+            .send_message::<_, responses::CreateScene>(Request::Create { canvas, name })
             .await
             .map(|cs| cs.uuid)
     }
 
     /// Removes a scene from OBS.
     #[doc(alias = "RemoveScene")]
-    pub async fn remove(&self, scene: SceneId<'_>) -> Result<()> {
-        self.client.send_message(Request::Remove { scene }).await
+    pub async fn remove(&self, canvas: Option<Uuid>, scene: SceneId<'_>) -> Result<()> {
+        self.client
+            .send_message(Request::Remove { canvas, scene })
+            .await
     }
 
     /// Gets the scene transition overridden for a scene.
     #[doc(alias = "GetSceneSceneTransitionOverride")]
     pub async fn transition_override(
         &self,
+        canvas: Option<Uuid>,
         scene: SceneId<'_>,
     ) -> Result<responses::SceneTransitionOverride> {
         self.client
-            .send_message(Request::TransitionOverride { scene })
+            .send_message(Request::TransitionOverride { canvas, scene })
             .await
     }
 

src/client/sources.rs

@@ -1,3 +1,5 @@
+use uuid::Uuid;
+
 use super::Client;
 use crate::{
     error::Result,
@@ -13,8 +15,14 @@ pub struct Sources<'a> {
 impl Sources<'_> {
     /// Gets the active and show state of a source.
     #[doc(alias = "GetSourceActive")]
-    pub async fn active(&self, source: SourceId<'_>) -> Result<responses::SourceActive> {
-        self.client.send_message(Request::Active { source }).await
+    pub async fn active(
+        &self,
+        canvas: Option<Uuid>,
+        source: SourceId<'_>,
+    ) -> Result<responses::SourceActive> {
+        self.client
+            .send_message(Request::Active { canvas, source })
+            .await
     }
 
     /// Gets a Base64-encoded screenshot of a source.

src/client/ui.rs

@@ -87,6 +87,7 @@ impl<'a> Ui<'a> {
     pub async fn open_source_projector(&self, open: OpenSourceProjector<'a>) -> Result<()> {
         self.client
             .send_message(Request::OpenSourceProjector(OpenSourceProjectorInternal {
+                canvas: open.canvas,
                 source: open.source,
                 location: open.location.map(Into::into),
             }))