feat(cava): add reload functionality and improve process management

- Implemented `_reload_cava` method to restart the cava process.
- Added callback registration for reload actions.
- Enhanced error handling during process termination and audio data reading.
- Created local directory for cava configuration files.

Author: amnweb

docs/widgets/(Widget)-Cava.md

@@ -26,6 +26,7 @@
 | `gradient_color_3` | string | "#cba6f7" | Third gradient color in hex format |
 | `hide_empty` | boolean | false | Hide widget when no audio is playing (requires `sleep_timer` to be enabled) |
 | `container_padding` | object | {top: 0, left: 0, bottom: 0, right: 0} | Padding of the widget container |
+| `callbacks`         | dict    | `{'on_left': 'do_nothing', 'on_middle': 'do_nothing', 'on_right': 'reload_cava'}` | Callbacks for mouse events on the widget. |
 
 ## Example Configuration
 
@@ -77,6 +78,7 @@
 - **gradient_color_3**: Third gradient color in hex format.
 - **hide_empty**: Hide widget when no audio is playing (requires `sleep_timer` to be enabled).
 - **container_padding**: Explicitly set padding inside widget container.
+- **callbacks**: A dictionary specifying the callbacks for mouse events. The keys are `on_left`, `on_middle`, and `on_right`, and the values are the names of the callback functions.
 
 More information on this option is documented in the [example config file](https://github.com/karlstav/cava/blob/master/example_files/config)
 

src/core/validation/widgets/yasb/cava.py

@@ -22,6 +22,11 @@
     'gradient_color_3': '#cba6f7',
     'hide_empty': False,
     'container_padding': {'top': 0, 'left': 0, 'bottom': 0, 'right': 0},
+    'callbacks': {
+        'on_left': 'do_nothing',
+        'on_middle': 'do_nothing',
+        'on_right': 'reload_cava'
+    }
 }
 
 VALIDATION_SCHEMA = {
@@ -152,5 +157,23 @@
             }
         },
         'default': DEFAULTS['container_padding']
+    },
+    'callbacks': {
+        'type': 'dict',
+        'schema': {
+            'on_left': {
+                'type': 'string',
+                'default': DEFAULTS['callbacks']['on_left'],
+            },
+            'on_middle': {
+                'type': 'string',
+                'default': DEFAULTS['callbacks']['on_middle'],
+            },
+            'on_right': {
+                'type': 'string',
+                'default': DEFAULTS['callbacks']['on_right'],
+            }
+        },
+        'default': DEFAULTS['callbacks']
     }
 }

src/core/widgets/yasb/cava.py

@@ -1,7 +1,7 @@
 import os
+from pathlib import Path
 import struct
 import subprocess
-import tempfile
 import textwrap
 import logging
 import shutil
@@ -69,6 +69,7 @@ def __init__(
             gradient_color_3: str,
             hide_empty: bool,
             container_padding: dict[str, int],
+            callbacks: dict[str, str],
     ):
         super().__init__(class_name="cava-widget")
         # Widget configuration
@@ -125,6 +126,12 @@ def __init__(
         self._bar_frame = CavaBar(self)
         self._widget_container_layout.addWidget(self._bar_frame)
 
+        self.register_callback("reload_cava", self._reload_cava)
+ 
+        self.callback_left = callbacks['on_left']
+        self.callback_right = callbacks['on_right']
+        self.callback_middle = callbacks['on_middle']
+        
         # Connect signal and start audio processing
         self.samplesUpdated.connect(self.on_samples_updated)
         self.destroyed.connect(self.stop_cava)
@@ -141,13 +148,35 @@ def __init__(
             QApplication.instance().aboutToQuit.connect(self.stop_cava)
         atexit.register(self.stop_cava)   
 
+
+    def _reload_cava(self):
+        """Stop current cava process and start a new one"""
+        try:
+            self.stop_cava()
+
+            self.samples = [0] * self._bars_number
+
+            QTimer.singleShot(500, self.start_cava)
+
+            if self._hide_empty and self._sleep_timer > 0:
+                if hasattr(self, '_hide_timer'):
+                    self._hide_timer.stop()
+                self._hide_cava_widget = True
+                self.show()
+        except Exception as e:
+            logging.error(f"Error reloading cava: {e}")
+
     def stop_cava(self) -> None:
         self._stop_cava = True
         if hasattr(self, "_cava_process") and self._cava_process.poll() is None:
-            self._cava_process.terminate()
+            try:
+                self._cava_process.terminate()
+                self._cava_process.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                self._cava_process.kill()
         if hasattr(self, "thread_cava") and self.thread_cava.is_alive():
             if threading.current_thread() != self.thread_cava:
-                self.thread_cava.join()
+                self.thread_cava.join(timeout=2)
 
     def initialize_colors(self) -> None:
         self.foreground_color = QColor(self._foreground)
@@ -180,6 +209,9 @@ def hide_bar_frame(self) -> None:
 
 
     def start_cava(self) -> None:
+        # Reset stop flag to allow new process to start
+        self._stop_cava = False
+        
         # Build configuration file, temp config file will be created in %temp% directory
         config_template = textwrap.dedent(f"""\
         # Cava config auto-generated by YASB
@@ -216,34 +248,52 @@ def start_cava(self) -> None:
             bytetype, bytesize, bytenorm = ("B", 1, 255)
 
         def process_audio():
+
+            LOCALDATA_FOLDER = Path(os.environ["LOCALAPPDATA"]) / "Yasb"
+            if not LOCALDATA_FOLDER.exists():
+                LOCALDATA_FOLDER.mkdir(parents=True, exist_ok=True)
+
+            cava_config_path = None
             try:
-                cava_config_path = os.path.join(tempfile.gettempdir(), "yasb_cava_config")
+                cava_config_path = LOCALDATA_FOLDER / Path(f"yasb_cava_config")
                 with open(cava_config_path, "w") as config_file:
                     config_file.write(config_template)
                     config_file.flush()
+                
                 self._cava_process = subprocess.Popen(
                     ["cava", "-p", cava_config_path],
                     stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
                     creationflags=subprocess.CREATE_NO_WINDOW
                 )
+                
                 chunk = bytesize * self._bars_number
                 fmt = bytetype * self._bars_number
-                while True:
+                
+                while not self._stop_cava:
                     try:
                         data = self._cava_process.stdout.read(chunk)
+                        if len(data) < chunk:
+                            break
+                        samples = [val / bytenorm for val in struct.unpack(fmt, data)]
+                        self.samplesUpdated.emit(samples)
                     except Exception as e:
-                        return
-                    if len(data) < chunk:
+                        logging.error(f"Error reading cava data: {e}")
                         break
-                    samples = [val / bytenorm for val in struct.unpack(fmt, data)]
-                    if self._stop_cava:
-                        break
-                    self.samplesUpdated.emit(samples)
+                        
             except Exception as e:
-                logging.error(f"Error processing audio in Cava: {e}")
-                self.stop_cava()
+                logging.error(f"Error starting cava process: {e}")
             finally:
-                self.stop_cava()
+                # Clean up config file
+                if cava_config_path and os.path.exists(cava_config_path):
+                    try:
+                        os.unlink(cava_config_path)
+                    except:
+                        pass
 
+        # Wait for previous thread to finish if it exists
+        if hasattr(self, 'thread_cava') and self.thread_cava.is_alive():
+            self.thread_cava.join(timeout=1)
+        
         self.thread_cava = threading.Thread(target=process_audio, daemon=True)
         self.thread_cava.start()