feat(widgets/volume): add "Hide When Inactive" toggle to volume widget (#3927)

* Add "Hide When Inactive" toggle to volume widget

* fix(volume-widget): fix clang-tidy warning and hide_when_inactive output behaviour

* fix(volume-widget): trigger rebuildState on PW_NODE_CHANGE_MASK_STATE for programs streams.

* feat(widgets/volume): add input-only "hide when inactive" toggle

---------

Co-authored-by: Lemmy <studio@quadbyte.net>

Author: Aron-dxd

assets/translations/en.json

@@ -3522,6 +3522,10 @@
           "description": "Hide the battery widget when fully charged",
           "label": "Hide When Full"
         },
+        "hide-when-inactive": {
+          "description": "Hide the microphone widget while no application is capturing audio",
+          "label": "Hide When Inactive"
+        },
         "hide-when-no-connected-device": {
           "description": "Hide the Bluetooth widget when no device is connected",
           "label": "Hide When No Connected Device"

src/shell/bar/widgets/volume_widget.cpp

@@ -21,7 +21,8 @@ VolumeWidget::VolumeWidget(PipeWireService* audio, EasyEffectsService* easyEffec
       m_muteColor(options.muteColor), m_glyphOverride(std::move(options.glyph)),
       m_muteGlyphOverride(std::move(options.muteGlyph)),
       m_effectsProfileGlyphs(std::move(options.effectsProfileGlyphs)),
-      m_customImage(widget_custom_image::fromConfig(options.customImage, options.customImageColorize)) {}
+      m_customImage(widget_custom_image::fromConfig(options.customImage, options.customImageColorize)),
+      m_hideWhenInactive(options.hideWhenInactive && options.device == VolumeWidgetTarget::Input) {}
 
 void VolumeWidget::create() {
   auto area = ui::inputArea({});
@@ -94,6 +95,16 @@ void VolumeWidget::doLayout(Renderer& renderer, float containerWidth, float cont
 
 void VolumeWidget::doUpdate(Renderer& renderer) { syncState(renderer); }
 
+void VolumeWidget::syncWidgetVisibility(bool showWidget) {
+  if (Node* rootNode = root(); rootNode != nullptr) {
+    if (rootNode->visible() != showWidget || rootNode->participatesInLayout() != showWidget) {
+      rootNode->setVisible(showWidget);
+      rootNode->setParticipatesInLayout(showWidget);
+      requestUpdate();
+    }
+  }
+}
+
 void VolumeWidget::syncState(Renderer& renderer) {
   if (m_audio == nullptr || (m_glyph == nullptr && m_image == nullptr) || m_label == nullptr) {
     return;
@@ -106,18 +117,32 @@ void VolumeWidget::syncState(Renderer& renderer) {
       m_target == VolumeWidgetTarget::Input ? AudioEffectsProfileKind::Input : AudioEffectsProfileKind::Output;
   const std::string effectsProfile =
       m_easyEffects != nullptr ? m_easyEffects->activeEffectsProfile(kind) : std::string{};
+  // Reuses the privacy signal: a microphone capture exists while an application is linked to a
+  // source. Skipped entirely for the output widget, where m_hideWhenInactive is always false.
+  const bool micActive =
+      m_hideWhenInactive && std::ranges::any_of(m_audio->privacyState().captures, [](const PrivacyCapture& capture) {
+        return capture.kind == PrivacyCaptureKind::Microphone;
+      });
 
   if (volume == m_lastVolume
       && muted == m_lastMuted
       && m_isVertical == m_lastVertical
-      && effectsProfile == m_lastEffectsProfile) {
+      && effectsProfile == m_lastEffectsProfile
+      && micActive == m_lastMicActive) {
     return;
   }
 
   m_lastVolume = volume;
   m_lastMuted = muted;
   m_lastVertical = m_isVertical;
   m_lastEffectsProfile = effectsProfile;
+  m_lastMicActive = micActive;
+
+  const bool showWidget = !m_hideWhenInactive || micActive;
+  syncWidgetVisibility(showWidget);
+  if (!showWidget) {
+    return;
+  }
 
   if (m_image != nullptr) {
     widget_custom_image::sync(

src/shell/bar/widgets/volume_widget.h

@@ -29,6 +29,7 @@ class VolumeWidget : public Widget {
     std::string customImage;
     bool customImageColorize = false;
     bool showLabel = true;
+    bool hideWhenInactive = false;
     ColorSpec muteColor = colorSpecFromRole(ColorRole::Error);
   };
 
@@ -40,6 +41,7 @@ class VolumeWidget : public Widget {
   void doLayout(Renderer& renderer, float containerWidth, float containerHeight) override;
   void doUpdate(Renderer& renderer) override;
   void syncState(Renderer& renderer);
+  void syncWidgetVisibility(bool showWidget);
   [[nodiscard]] std::string glyphName(float volume, bool muted, const std::string& effectsProfile = {}) const;
 
   PipeWireService* m_audio = nullptr;
@@ -51,6 +53,8 @@ class VolumeWidget : public Widget {
   std::string m_muteGlyphOverride;
   std::unordered_map<std::string, std::string> m_effectsProfileGlyphs;
   WidgetCustomImage m_customImage;
+  // Only ever true for the input widget: "inactive" means no application is capturing audio.
+  bool m_hideWhenInactive = false;
   Glyph* m_glyph = nullptr;
   Image* m_image = nullptr;
   Label* m_label = nullptr;
@@ -59,4 +63,5 @@ class VolumeWidget : public Widget {
   bool m_lastMuted = false;
   bool m_isVertical = false;
   bool m_lastVertical = false;
+  bool m_lastMicActive = false;
 };

src/shell/bar/widgets/volume_widget_definition.cpp

@@ -52,6 +52,13 @@ const noctalia::bar::WidgetDefinition<VolumeWidget::Options>& volumeWidgetDefini
               field<&Options::muteColor>({
                   .key = "mute_color",
               }),
+              field<&Options::hideWhenInactive>({
+                  .key = "hide_when_inactive",
+                  .presentation =
+                      settings::WidgetSettingPresentation{
+                          .visibleWhen = settings::WidgetSettingVisibility{"device", {"input"}},
+                      },
+              }),
           },
       .glyph = [](const Options& options) -> std::string {
         if (!options.glyph.empty()) {

tests/widget_definition_test.cpp

@@ -274,6 +274,32 @@ int main() {
   if (pickerGlyph("network-download") != "download") {
     fail("sysmon", "network receive stat did not select the download picker glyph");
   }
+
+  // hide_when_inactive keys off microphone capture, so the settings UI must only offer it on a
+  // volume widget bound to the input device.
+  WidgetConfig outputVolume;
+  outputVolume.type = "volume";
+  glyphConfig.widgets.emplace("speaker", std::move(outputVolume));
+  const auto hideWhenInactiveVisible = [&](std::string_view widgetName) {
+    const WidgetConfig& widget = glyphConfig.widgets.at(std::string(widgetName));
+    const auto specs = settings::widgetSettingSpecs("volume", &widget, "", false);
+    const auto spec = std::ranges::find(specs, "hide_when_inactive", [](const settings::WidgetSettingSpec& candidate) {
+      return std::string_view(candidate.schema.key);
+    });
+    if (spec == specs.end()) {
+      fail("volume", "hide_when_inactive is missing from the settings specs");
+      return false;
+    }
+    return settings::widgetSettingIsVisible(
+        glyphConfig, widgetName, *spec, specs, settings::WidgetSettingCapabilities{}
+    );
+  };
+  if (!hideWhenInactiveVisible("mic")) {
+    fail("volume", "hide_when_inactive is hidden on an input widget");
+  }
+  if (hideWhenInactiveVisible("speaker")) {
+    fail("volume", "hide_when_inactive is offered on an output widget");
+  }
   checkDefinition("wallpaper", wallpaperWidgetDefinition);
   checkDefinition("weather", weatherWidgetDefinition);