Add natural language time and copy-time shortcut

Author: M-Rajabi-dev

frames/player/controls.py

@@ -147,7 +147,7 @@ def on_key_down(frame, event: wx.KeyEvent):
     # Info Announcements
     elif keycode == ord('I'):
         if ctrl_down:
-            frame.info_manager.announce_info()
+            frame.info_manager.copy_current_time()
         elif alt_down:
             frame.info_manager.announce_remaining_file_time()
         elif shift_down:

frames/player/info.py

@@ -19,29 +19,73 @@ class InfoManager:
     def __init__(self, frame):
         self.frame = frame
 
+    def _get_spoken_duration(self, ms):
+        """Helper to convert ms to spoken string like '2 hours, 5 minutes'."""
+        if ms < 0: ms = 0
+        total_seconds = int(ms / 1000)
+        hours = total_seconds // 3600
+        minutes = (total_seconds % 3600) // 60
+        seconds = total_seconds % 60
+
+        parts = []
+        
+        # Handle Hours
+        if hours > 0:
+            label = "hour" if hours == 1 else "hours"
+            parts.append(f"{hours} {label}")
+        
+        # Handle Minutes (Always show unless 0 and we have hours, but user wants detail)
+        if minutes > 0:
+            label = "minute" if minutes == 1 else "minutes"
+            parts.append(f"{minutes} {label}")
+            
+        # Handle Seconds (Show if it's the only thing, or generally for precision)
+        if seconds > 0 or not parts:
+            label = "second" if seconds == 1 else "seconds"
+            parts.append(f"{seconds} {label}")
+
+        return ", ".join(parts)
+
     def announce_time(self, should_speak_time: bool):
         """
-        Updates the time display label on the UI.
-        Optionally speaks the current time (used by the 'I' hotkey).
-
-        Args:
-            should_speak_time: If True, triggers NVDA speech.
+        Announces: You have listened to X of Y.
         """
         if self.frame.is_exiting or not self.frame.engine or self.frame.IsBeingDeleted() or not self.frame.time_text:
             return
 
         try:
-            current_time = self.frame.engine.get_time()
-            total_time = self.frame.current_file_duration_ms
-            time_str = f"{format_time(current_time)} / {format_time(total_time if total_time > 0 else 0)}"
+            current_ms = self.frame.engine.get_time()
+            total_ms = self.frame.current_file_duration_ms
 
-            wx.CallAfter(self._update_time_label, time_str)
+            # Update visual label (Keep mathematical for visual, or change if you like)
+            # For visuals, we stick to standard format usually, but here is the logic:
+            time_str_visual = f"{format_time(current_ms)} / {format_time(total_ms if total_ms > 0 else 0)}"
+            wx.CallAfter(self._update_time_label, time_str_visual)
 
             if should_speak_time:
-                speak(time_str, LEVEL_CRITICAL)
+                spoken_current = self._get_spoken_duration(current_ms)
+                spoken_total = self._get_spoken_duration(total_ms)
+                # Spoken: "You have listened to 5 minutes of 10 minutes"
+                msg = _("You have listened to {0} of {1}").format(spoken_current, spoken_total)
+                speak(msg, LEVEL_CRITICAL)
         except Exception as e:
             logging.debug(f"Ignoring exception during announce_time: {e}")
 
+    def copy_current_time(self):
+        if not self.frame.engine:
+            return
+
+        try:
+            current_ms = self.frame.engine.get_time()
+            time_str = format_time(current_ms)
+
+            if wx.TheClipboard.Open():
+                wx.TheClipboard.SetData(wx.TextDataObject(time_str))
+                wx.TheClipboard.Close()
+                speak(_("Time copied."), LEVEL_MINIMAL)
+        except Exception as e:
+            logging.error(f"Failed to copy time to clipboard: {e}")
+
     def _update_time_label(self, time_str: str):
         """Safely updates the time label on the main thread."""
         if self.frame and not self.frame.IsBeingDeleted() and self.frame.time_text:
@@ -51,76 +95,56 @@ def _update_time_label(self, time_str: str):
             except wx.PyDeadObjectError:
                 logging.warning("Failed to update time label, object likely destroyed.")
 
-    def announce_info(self):
-        """Speaks the current book title and file name."""
-        book_title = self.frame.book_title
-        file_path = self.frame.current_file_path
-        
-        if not file_path:
-            file_name = _("Unknown File")
-        else:
-            file_name = os.path.basename(file_path)
-        
-        speak(f"{_('Book')}: {book_title}. {file_name}", LEVEL_CRITICAL)
-
-    def announce_file_only(self):
-        """Speaks only the current file name (used on file change)."""
-        file_path = self.frame.current_file_path
-        
-        if not file_path:
-            file_name = _("Unknown File")
-        else:
-            file_name = os.path.basename(file_path)
-        
-        speak(f"{file_name}", LEVEL_MINIMAL)
-
     def announce_remaining_file_time(self):
-        """Calculates and announces the time remaining in the current file."""
+        """
+        Announces: X remaining of Y.
+        """
         if not self.frame.engine:
             return
 
         try:
-            duration_ms = self.frame.current_file_duration_ms
-            if duration_ms <= 0:
+            total_ms = self.frame.current_file_duration_ms
+            if total_ms <= 0:
                 speak(_("File duration not yet known."), LEVEL_CRITICAL)
                 return
 
-            current_time_ms = self.frame.engine.get_time()
-            remaining_ms = duration_ms - current_time_ms
-            if remaining_ms < 0:
-                remaining_ms = 0
+            current_ms = self.frame.engine.get_time()
+            remaining_ms = max(0, total_ms - current_ms)
 
-            speak(_("Time remaining: {0}").format(format_time(remaining_ms)), LEVEL_CRITICAL)
+            spoken_remaining = self._get_spoken_duration(remaining_ms)
+            spoken_total = self._get_spoken_duration(total_ms)
+
+            # Spoken: "5 minutes remaining of 10 minutes"
+            speak(_("{0} remaining of {1}").format(spoken_remaining, spoken_total), LEVEL_CRITICAL)
         except Exception as e:
             logging.error(f"Error announcing remaining file time: {e}", exc_info=True)
 
     def announce_adjusted_remaining_file_time(self):
         """
-        Calculates and announces time remaining in the current file,
-        adjusted for the current playback speed.
+        Announces remaining time adjusted by speed.
         """
         if not self.frame.engine:
             return
 
         try:
-            duration_ms = self.frame.current_file_duration_ms
+            total_ms = self.frame.current_file_duration_ms
             current_rate = self.frame.current_target_rate
 
-            if duration_ms <= 0:
+            if total_ms <= 0:
                 speak(_("File duration not yet known."), LEVEL_MINIMAL)
                 return
             if current_rate == 0:
                 speak(_("Playback speed is zero."), LEVEL_MINIMAL)
                 return
 
-            current_time_ms = self.frame.engine.get_time()
-            real_remaining_ms = duration_ms - current_time_ms
-            if real_remaining_ms < 0:
-                real_remaining_ms = 0
-
+            current_ms = self.frame.engine.get_time()
+            real_remaining_ms = max(0, total_ms - current_ms)
             adjusted_remaining_ms = int(real_remaining_ms / current_rate)
-            speak(_("Time remaining at current speed: {0}").format(format_time(adjusted_remaining_ms)),
-                  LEVEL_CRITICAL)
+
+            spoken_adjusted = self._get_spoken_duration(adjusted_remaining_ms)
+            
+            # Spoken: "3 minutes remaining at current speed"
+            speak(_("{0} remaining at current speed").format(spoken_adjusted), LEVEL_CRITICAL)
         except Exception as e:
             logging.error(f"Error announcing adjusted remaining file time: {e}", exc_info=True)
 
@@ -181,41 +205,44 @@ def _calculate_total_elapsed_ms(self) -> int:
         return total_elapsed_ms
 
     def announce_total_elapsed_time(self):
-        """Announces total elapsed time and total book duration."""
+        """Announces total elapsed vs total book duration verbally."""
         if not hasattr(self.frame, 'total_book_duration_ms'):
             speak(_("Book duration data not available."), LEVEL_MINIMAL)
             return
 
         try:
             elapsed_ms = self._calculate_total_elapsed_ms()
             total_ms = self.frame.total_book_duration_ms
-            speak(_("Elapsed: {0} / Total: {1}").format(
-                format_time(elapsed_ms), format_time(total_ms)), LEVEL_CRITICAL)
+            
+            spoken_elapsed = self._get_spoken_duration(elapsed_ms)
+            spoken_total = self._get_spoken_duration(total_ms)
+
+            msg = _("You have listened to {0} of {1}").format(spoken_elapsed, spoken_total)
+            speak(msg, LEVEL_CRITICAL)
         except Exception as e:
             logging.error(f"Error announcing total elapsed time: {e}", exc_info=True)
 
     def announce_total_remaining_time(self):
-        """Announces the total time remaining in the entire book."""
+        """Announces total remaining time verbally."""
         if not hasattr(self.frame, 'total_book_duration_ms'):
             speak(_("Book duration data not available."), LEVEL_MINIMAL)
             return
 
         try:
             elapsed_ms = self._calculate_total_elapsed_ms()
             total_ms = self.frame.total_book_duration_ms
-            remaining_ms = total_ms - elapsed_ms
-            if remaining_ms < 0:
-                remaining_ms = 0
+            remaining_ms = max(0, total_ms - elapsed_ms)
 
-            speak(_("Total time remaining: {0}").format(format_time(remaining_ms)), LEVEL_CRITICAL)
+            spoken_remaining = self._get_spoken_duration(remaining_ms)
+            spoken_total = self._get_spoken_duration(total_ms)
+
+            msg = _("{0} remaining of {1}").format(spoken_remaining, spoken_total)
+            speak(msg, LEVEL_CRITICAL)
         except Exception as e:
             logging.error(f"Error announcing total remaining time: {e}", exc_info=True)
 
     def announce_adjusted_total_remaining_time(self):
-        """
-        Announces total time remaining in the book, adjusted for the
-        current playback speed.
-        """
+        """Announces adjusted total remaining time verbally."""
         if not hasattr(self.frame, 'total_book_duration_ms') or not hasattr(self.frame, 'current_target_rate'):
             speak(_("Book duration data not available."), LEVEL_MINIMAL)
             return
@@ -228,12 +255,11 @@ def announce_adjusted_total_remaining_time(self):
 
             elapsed_ms = self._calculate_total_elapsed_ms()
             total_ms = self.frame.total_book_duration_ms
-            real_remaining_ms = total_ms - elapsed_ms
-            if real_remaining_ms < 0:
-                real_remaining_ms = 0
-
+            real_remaining_ms = max(0, total_ms - elapsed_ms)
             adjusted_remaining_ms = int(real_remaining_ms / current_rate)
-            speak(_("Total time remaining at current speed: {0}").format(
-                format_time(adjusted_remaining_ms)), LEVEL_CRITICAL)
+            
+            spoken_adjusted = self._get_spoken_duration(adjusted_remaining_ms)
+
+            speak(_("{0} remaining of book at current speed").format(spoken_adjusted), LEVEL_CRITICAL)
         except Exception as e:
-            logging.error(f"Error announcing adjusted total remaining time: {e}", exc_info=True)
+            logging.error(f"Error announcing adjusted total remaining time: {e}", exc_info=True)