To make Fenrir easier to approach for new developer, start code migration to be pep8 compliant.

.gitignore

@@ -6,3 +6,4 @@ dist/
 build/
 *.kate-swp
 .directory
+CLAUDE.md

README.md

@@ -511,6 +511,7 @@ fenrir [OPTIONS]
 - `-e, --emulated-pty` - Use PTY emulation with escape sequences for input (enables desktop/X/Wayland usage)
 - `-E, --emulated-evdev` - Use PTY emulation with evdev for input (single instance)
 - `-F, --force-all-screens` - Force Fenrir to respond on all screens, ignoring ignoreScreen setting
+- `-i, -I, --ignore-screen SCREEN` - Ignore specific screen(s). Can be used multiple times. Combines with existing ignore settings.
 
 ### Examples:
 ```bash
@@ -525,6 +526,10 @@ sudo fenrir -o "speech#rate=0.8;sound#volume=0.5"
 
 # Force Fenrir to work on all screens (ignore ignoreScreen setting)
 sudo fenrir -F
+
+# Ignore specific screens
+sudo fenrir --ignore-screen 1
+sudo fenrir -i 1 -i 2    # Ignore screens 1 and 2
 ```
 
 ## Localization

config/keyboard/desktop.conf

@@ -73,7 +73,8 @@ KEY_FENRIR,KEY_SHIFT,KEY_0=set_bookmark_10
 KEY_FENRIR,KEY_0=bookmark_10
 KEY_FENRIR,KEY_KPSLASH=set_window_application
 2,KEY_FENRIR,KEY_KPSLASH=clear_window_application
-KEY_KPPLUS=last_incoming
+KEY_KPPLUS=progress_bar_monitor
+#KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
 KEY_FENRIR,KEY_F2=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech
@@ -113,6 +114,8 @@ KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_X=remove_marks
 KEY_FENRIR,KEY_X=set_mark
 KEY_FENRIR,KEY_SHIFT,KEY_X=marked_text
 KEY_FENRIR,KEY_F10=toggle_vmenu_mode
+KEY_FENRIR,KEY_SHIFT,KEY_F10=voice_browser_safe
+KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_F10=apply_tested_voice
 KEY_FENRIR,KEY_SPACE=current_quick_menu_entry
 KEY_FENRIR,KEY_CTRL,KEY_SPACE=current_quick_menu_value
 KEY_FENRIR,KEY_RIGHT=next_quick_menu_entry

config/keyboard/laptop.conf

@@ -75,9 +75,11 @@ KEY_FENRIR,KEY_F2=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech
 KEY_FENRIR,KEY_ENTER=temp_disable_speech
+KEY_FENRIR,KEY_SHIFT,KEY_P=progress_bar_monitor
+#KEY_FENRIR,KEY_SHIFT,KEY_ENTER=silence_until_prompt
 KEY_FENRIR,KEY_SHIFT,KEY_CTRL,KEY_P=toggle_punctuation_level
 KEY_FENRIR,KEY_RIGHTBRACE=toggle_auto_spell_check
-KEY_FENRIR,KEY_SHIFT,KEY_ENTER=toggle_output
+KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_ENTER=toggle_output
 KEY_FENRIR,KEY_SHIFT,KEY_E=toggle_emoticons
 KEY_FENRIR,KEY_ENTER=toggle_auto_read
 KEY_FENRIR,KEY_CTRL,KEY_T=toggle_auto_time
@@ -111,6 +113,8 @@ KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_X=remove_marks
 KEY_FENRIR,KEY_X=set_mark
 KEY_FENRIR,KEY_SHIFT,KEY_X=marked_text
 KEY_FENRIR,KEY_F10=toggle_vmenu_mode
+KEY_FENRIR,KEY_SHIFT,KEY_F10=voice_browser_safe
+KEY_FENRIR,KEY_CTRL,KEY_SHIFT,KEY_F10=apply_tested_voice
 KEY_FENRIR,KEY_SPACE=current_quick_menu_entry
 KEY_FENRIR,KEY_CTRL,KEY_SPACE=current_quick_menu_value
 KEY_FENRIR,KEY_RIGHT=next_quick_menu_entry

config/keyboard/nvda-desktop.conf

@@ -72,7 +72,8 @@ KEY_FENRIR,KEY_SHIFT,KEY_0=set_bookmark_10
 KEY_FENRIR,KEY_0=bookmark_10
 KEY_FENRIR,KEY_KPSLASH=set_window_application
 2,KEY_FENRIR,KEY_KPSLASH=clear_window_application
-KEY_KPPLUS=last_incoming
+KEY_KPPLUS=progress_bar_monitor
+KEY_FENRIR,KEY_KPPLUS=silence_until_prompt
 #=toggle_braille
 KEY_FENRIR,KEY_F3=toggle_sound
 KEY_FENRIR,KEY_F4=toggle_speech

config/settings/settings.conf

@@ -28,6 +28,9 @@ genericPlayFileCommand=play -q -v fenrirVolume fenrirSoundFile
 #the following command is used to generate a frequency beep
 genericFrequencyCommand=play -q -v fenrirVolume -n -c1 synth fenrirDuration sine fenrirFrequence
 
+# Enable progress bar monitoring with ascending tones by default
+progressMonitoring=True
+
 [speech]
 # Turn speech on or off:
 enabled=True
@@ -92,7 +95,7 @@ fenrirMaxRate=450
 driver=vcsaDriver
 encoding=auto
 screenUpdateDelay=0.05
-ignoreScreen=
+ignoreScreen=7
 autodetectIgnoreScreen=True
 
 [keyboard]
@@ -121,7 +124,9 @@ interruptOnKeyPressFilter=
 doubleTapTimeout=0.2
 
 [general]
-debugLevel=0
+# Debug levels: 0=DEACTIVE, 1=ERROR, 2=WARNING, 3=INFO (most verbose)
+# For production use, WARNING (2) provides good balance of useful info without spam
+debugLevel=2
 # debugMode sets where the debug output should send to:
 # debugMode=File writes to debugFile (Default:/tmp/fenrir-PID.log)
 # debugMode=Print just prints on the screen
@@ -140,8 +145,8 @@ emoticons=True
 # define the current Fenrir key
 fenrirKeys=KEY_KP0,KEY_META,KEY_INSERT
 scriptKeys=KEY_COMPOSE
-timeFormat=%H:%M:%P
-dateFormat=%A, %B %d, %Y
+timeFormat=%%I:%%M%%P
+dateFormat=%%A, %%B %%d, %%Y
 autoSpellCheck=True
 spellCheckLanguage=en_US
 # path for your scripts "scriptKeys" functionality
@@ -163,7 +168,7 @@ autoPresentIndent=False
 # 1 = sound only
 # 2 = speak only
 autoPresentIndentMode=1
-# play a sound when attributes are changeing
+# play a sound when attributes change
 hasAttributes=True
 # shell for PTY emulatiun (empty = default shell)
 shell=
@@ -211,8 +216,32 @@ list=
 vmenuPath=
 quickMenu=speech#rate;speech#pitch;speech#volume
 
+[prompt]
+# Custom prompt patterns for silence until prompt feature
+# You can add your own shell prompt patterns as regular expressions
+# Each pattern should be on a separate line, format: customPatterns=pattern1,pattern2,pattern3
+# 
+# Built-in patterns include:
+# - Shell prompts: $, #, >, user@host$, [user@host]$, bash-5.1$
+# - Package manager prompts: [Y/n], [y/N], [Yes/No], (Y/n), (y/N)
+# - sudo prompts: [sudo] password for user:, Password:, user's password:
+# - Confirmation prompts: Press any key, Are you sure?, Please confirm
+#
+# Custom pattern examples:
+# For PS1='[\u@\h \W] \$ ' use: \[.*@.*\s.*\]\s*[$#>]\s*
+# For "[user@hostname ~] $" use: \[.*@.*\s.*\]\s*[$#>]\s*
+# For custom prompts ending with specific strings, use patterns like: .*your_prompt_ending$
+# For custom package manager prompts: .*your_package_manager.*\[[YyNn]/[YyNn]\].*
+customPatterns=
+
+# Specific prompt strings to match exactly (useful for very specific custom prompts)
+# Format: exactMatches=prompt1,prompt2,prompt3
+# Examples:
+# exactMatches=[storm@fenrir ~] $,[root@fenrir ~] #,Continue installation? [Y/n]
+exactMatches=
+
 [time]
-# automatic time anouncement
+# automatic time announcement
 enabled=False
 # present time
 presentTime=True

config/sound/default/soundicons.conf

@@ -30,9 +30,6 @@ ContentChanged='ContentChanged.wav'
 # Speech has turned On or Off
 SpeechOn='SpeechOn.wav'
 SpeechOff='SpeechOff.wav'
-# Braille has turned On or Off
-BrailleOn='BrailleOn.wav'
-BrailleOff='BrailleOff.wav'
 # SoundIcons has turned On or Off
 SoundOn='SoundOn.wav'
 SoundOff='SoundOff.wav'
@@ -44,9 +41,8 @@ PlaceEndMark='PlaceEndMark.wav'
 CopyToClipboard='CopyToClipboard.wav'
 # Pasted on the screen
 PasteClipboardOnScreen='PasteClipboardOnScreen.wav'
-# An error accoured while speech or braille output or reading the screen
+# An error accoured while speech output or reading the screen
 ErrorSpeech='ErrorSpeech.wav'
-ErrorBraille='ErrorBraille.wav'
 ErrorScreen='ErrorScreen.wav'
 # If you cursor over an text that has attributs (like color)
 HasAttributes='has_attribute.wav'

docs/fenrir.1

@@ -65,6 +65,10 @@ Use PTY emulation with evdev for input (single instance mode).
 .BR \-F ", " \-\-force-all-screens
 Force Fenrir to respond on all screens, ignoring the ignoreScreen setting. This temporarily overrides screen filtering for the current session.
 
+.TP
+.BR \-i ", " \-I ", " \-\-ignore-screen " \fISCREEN\fR"
+Ignore specific screen(s). Can be used multiple times to ignore multiple screens. This is equivalent to setting ignoreScreen in the configuration file and will be combined with any existing ignore settings.
+
 .SH KEY CONCEPTS
 
 .SS Fenrir Key

docs/fenrir.adoc

@@ -1240,6 +1240,9 @@ Use PTY emulation with evdev for input (single instance mode).
 `+-F, --force-all-screens+`::
 Force Fenrir to respond on all screens, ignoring the ignoreScreen setting. This temporarily overrides screen filtering for the current session.
 
+`+-i, -I, --ignore-screen <SCREEN>+`::
+Ignore specific screen(s). Can be used multiple times to ignore multiple screens. This is equivalent to setting ignoreScreen in the configuration file and will be combined with any existing ignore settings.
+
 ==== Set settings options
 
 You can specify options that overwrite the setting.conf. This is done

docs/user.md

@@ -297,6 +297,7 @@ fenrir [OPTIONS]
 - `-e, --emulated-pty` - PTY emulation for desktop use
 - `-E, --emulated-evdev` - PTY + evdev emulation
 - `-F, --force-all-screens` - Ignore ignoreScreen setting
+- `-i, -I, --ignore-screen SCREEN` - Ignore specific screen(s), can be used multiple times
 
 ## Troubleshooting
 

requirements.txt

@@ -1,4 +1,5 @@
 daemonize
+dbus-python
 evdev
 pexpect
 pyenchant

setup.py

@@ -37,7 +37,7 @@ for directory in directories:
         if not forceSettingsFlag:
             try:
                 files = [f for f in files if not f.endswith('settings.conf')]
-            except:
+            except Exception as e:
                 pass
     elif 'config/scripts' in directory:
         destDir = '/usr/share/fenrirscreenreader/scripts'

src/fenrir

@@ -72,6 +72,12 @@ def create_argument_parser():
         action='store_true',
         help='Force Fenrir to respond on all screens, ignoring ignoreScreen setting'
     )
+    argumentParser.add_argument(
+        '-i', '-I', '--ignore-screen',
+        metavar='SCREEN',
+        action='append',
+        help='Ignore specific screen(s). Can be used multiple times. Same as ignoreScreen setting.'
+    )
     return argumentParser
 
 def validate_arguments(cliArgs):

src/fenrirscreenreader/commands/command_template.py

@@ -4,18 +4,25 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return 'No description found'
+
     def run(self):
         pass
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/00_init_commands.py

@@ -4,23 +4,33 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
 
 # this command is just to initialize stuff.
 # like init index lists in memoryManager
 # it is not useful to execute it
+
+from fenrirscreenreader.core.i18n import _
+
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
         # clipboard
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env['runtime']['memoryManager'].addIndexList(
+            'clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt(
+                'general', 'numberOfClipboards'))
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return 'No description found'
+
     def run(self):
         pass
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/add_word_to_spell_check.py

@@ -4,51 +4,69 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import word_utils
 import string
 initialized = False
 try:
     import enchant
     initialized = True
-except:
+except Exception as e:
     pass
 
+
 class command():
     def __init__(self):
         self.language = ''
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
         self.updateSpellLanguage()
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('adds the current word to the exceptions dictionary')
+
     def updateSpellLanguage(self):
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
+        self.spellChecker = enchant.Dict(
+            self.env['runtime']['settingsManager'].getSetting(
+                'general', 'spellCheckLanguage'))
+        self.language = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'spellCheckLanguage')
 
     def run(self):
         if not initialized:
-           return
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+            return
+        if self.env['runtime']['settingsManager'].getSetting(
+                'general', 'spellCheckLanguage') != self.language:
             try:
                 self.updateSpellLanguage()
             except Exception as e:
                 return
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)
-        currWord = currWord.strip(string.whitespace + r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~')
+        newContent = self.env['screen']['newContentText'].split('\n')[
+            cursorPos['y']]
+        x, y, currWord, endOfScreen, lineBreak = word_utils.getCurrentWord(
+            cursorPos['x'], 0, newContent)
+        currWord = currWord.strip(
+            string.whitespace +
+            r'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~')
 
         if currWord != '':
             if self.spellChecker.is_added(currWord):
-                self.env['runtime']['outputManager'].presentText(_('{0} is already in dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+                self.env['runtime']['outputManager'].presentText(
+                    _('{0} is already in dictionary').format(
+                        currWord,), soundIcon='Cancel', interrupt=True)
             else:
                 self.spellChecker.add(currWord)
-                self.env['runtime']['outputManager'].presentText(_('{0} added to dictionary').format(currWord,), soundIcon='Accept', interrupt=True)               
+                self.env['runtime']['outputManager'].presentText(
+                    _('{0} added to dictionary').format(
+                        currWord,), soundIcon='Accept', interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/adjustment_base.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+
+from fenrirscreenreader.core.i18n import _
+
+import math
+
+
+class AdjustmentCommand():
+    """Base class for speech and sound adjustment commands"""
+
+    def __init__(self, section, setting, direction, step=0.1):
+        self.section = section  # 'speech' or 'sound'
+        self.setting = setting  # 'rate', 'pitch', 'volume'
+        self.direction = direction  # 'inc' or 'dec'
+        self.step = step
+
+    def initialize(self, environment):
+        self.env = environment
+
+    def shutdown(self):
+        pass
+
+    def getDescription(self):
+        action = "Increase" if self.direction == 'inc' else "Decrease"
+        if self.section == 'speech':
+            return _(f'{action} the speech {self.setting}')
+        else:
+            return _(f'{action} the {self.section} {self.setting}')
+
+    def run(self):
+        if self.section == 'sound' and self.setting == 'volume':
+            # Sound volume uses different method
+            self._adjust_sound_volume()
+        else:
+            # Speech rate, pitch, volume use standard method
+            self._adjust_speech_setting()
+
+    def _adjust_speech_setting(self):
+        """Adjust speech settings (rate, pitch, volume)"""
+        value = self.env['runtime']['settingsManager'].getSettingAsFloat(
+            self.section, self.setting)
+
+        # Apply adjustment with rounding
+        if self.direction == 'inc':
+            value = round((math.ceil(10 * value) / 10) + self.step, 2)
+            if value > 1.0:
+                value = 1.0
+        else:  # dec
+            value = round((math.ceil(10 * value) / 10) - self.step, 2)
+            if value < 0.0:
+                value = 0.0
+
+        # Set the new value
+        self.env['runtime']['settingsManager'].setSetting(
+            self.section, self.setting, str(value))
+
+        # Present feedback
+        percentage = int(value * 100)
+        if self.section == 'speech':
+            feedback = _("{0} percent speech {1}").format(
+                percentage, self.setting)
+        else:
+            feedback = _("{0} percent {1} {2}").format(
+                percentage, self.section, self.setting)
+
+        self.env['runtime']['outputManager'].presentText(
+            feedback, soundIcon='', interrupt=True)
+
+    def _adjust_sound_volume(self):
+        """Adjust sound volume using same logic as speech"""
+        value = self.env['runtime']['settingsManager'].getSettingAsFloat(
+            self.section, self.setting)
+
+        # Sound volume uses same math as speech settings
+        if self.direction == 'inc':
+            value = round((math.ceil(10 * value) / 10) + self.step, 2)
+            if value > 1.0:
+                value = 1.0
+        else:  # dec
+            value = round((math.ceil(10 * value) / 10) - self.step, 2)
+            if value < 0.0:
+                value = 0.0
+
+        # Set the new value
+        self.env['runtime']['settingsManager'].setSetting(
+            self.section, self.setting, str(value))
+
+        # Present feedback with appropriate sound icon
+        percentage = int(value * 100)
+        sound_icon = 'SoundOn' if self.direction == 'inc' else 'SoundOff'
+        feedback = _("{0} percent sound volume").format(percentage)
+        self.env['runtime']['outputManager'].presentText(
+            feedback, soundIcon=sound_icon, interrupt=True)
+
+    def setCallback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/announce_fenrir_version.py

@@ -4,24 +4,33 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader import fenrirVersion
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Present the version of Fenrir currrrently in use.')
 
     def run(self):
         try:
-            self.env['runtime']['outputManager'].presentText(f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}', interrupt=True)
-        except exception as e:
-            self.env['runtime']['outputManager'].presentText(_('Version information is unavailable.'), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                f'Fenrir screen reader version {
+                    fenrirVersion.version}-{
+                    fenrirVersion.codeName}', interrupt=True)
+        except Exception as e:
+            self.env['runtime']['outputManager'].presentText(
+                _('Version information is unavailable.'), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/apply_tested_voice.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+
+from fenrirscreenreader.core.i18n import _
+
+
+class command():
+    def __init__(self):
+        pass
+
+    def initialize(self, environment):
+        self.env = environment
+
+    def shutdown(self):
+        pass
+
+    def getDescription(self):
+        return "Apply the last tested voice from safe voice browser"
+
+    def run(self):
+        try:
+            # Check if we have a tested voice
+            if ('commandBuffer' not in self.env or
+                'lastTestedModule' not in self.env['commandBuffer'] or
+                    'lastTestedVoice' not in self.env['commandBuffer']):
+                self.env['runtime']['outputManager'].presentText(
+                    "No voice has been tested yet", interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    "Use voice browser first", interrupt=True)
+                return
+
+            module = self.env['commandBuffer']['lastTestedModule']
+            voice = self.env['commandBuffer']['lastTestedVoice']
+
+            self.env['runtime']['outputManager'].presentText(
+                f"Applying {voice} from {module}", interrupt=True)
+
+            # Apply to runtime settings only (temporary until saved)
+            settingsManager = self.env['runtime']['settingsManager']
+
+            # Store old values for safety
+            oldDriver = settingsManager.getSetting('speech', 'driver')
+            oldModule = settingsManager.getSetting('speech', 'module')
+            oldVoice = settingsManager.getSetting('speech', 'voice')
+
+            try:
+                # Apply new settings to runtime only (use setSetting to update
+                # settingArgDict)
+                settingsManager.setSetting('speech', 'driver', 'speechdDriver')
+                settingsManager.setSetting('speech', 'module', module)
+                settingsManager.setSetting('speech', 'voice', voice)
+
+                # Apply to speech driver instance directly
+                if 'speechDriver' in self.env['runtime']:
+                    speechDriver = self.env['runtime']['speechDriver']
+
+                    # Set the module and voice on the driver instance
+                    speechDriver.setModule(module)
+                    speechDriver.setVoice(voice)
+
+                    self.env['runtime']['outputManager'].presentText(
+                        "Voice applied successfully!", interrupt=True)
+                    self.env['runtime']['outputManager'].presentText(
+                        "Use save settings to make permanent", interrupt=True)
+                    self.env['runtime']['outputManager'].playSound('Accept')
+
+            except Exception as e:
+                # Revert on failure
+                settingsManager.setSetting('speech', 'driver', oldDriver)
+                settingsManager.setSetting('speech', 'module', oldModule)
+                settingsManager.setSetting('speech', 'voice', oldVoice)
+
+                self.env['runtime']['outputManager'].presentText(
+                    f"Failed to apply voice, reverted: {str(e)}", interrupt=True)
+                self.env['runtime']['outputManager'].playSound('Error')
+
+        except Exception as e:
+            self.env['runtime']['outputManager'].presentText(
+                f"Apply voice error: {str(e)}", interrupt=True)
+            self.env['runtime']['outputManager'].playSound('Error')
+
+    def setCallback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/attribute_cursor.py

@@ -4,27 +4,38 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import screen_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Reads attributes of current cursor position')
+
     def run(self):
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
         try:
-            attributes = self.env['runtime']['attributeManager'].getAttributeByXY( cursorPos['x'], cursorPos['y'])
+            attributes = self.env['runtime']['attributeManager'].getAttributeByXY(
+                cursorPos['x'], cursorPos['y'])
         except Exception as e:
             print(e)
-        attributeFormatString = self.env['runtime']['settingsManager'].getSetting('general', 'attributeFormatString')
-        attributeFormatString = self.env['runtime']['attributeManager'].formatAttributes(attributes, attributeFormatString)
+        attributeFormatString = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'attributeFormatString')
+        attributeFormatString = self.env['runtime']['attributeManager'].formatAttributes(
+            attributes, attributeFormatString)
+
+        self.env['runtime']['outputManager'].presentText(
+            attributeFormatString, soundIcon='', interrupt=True)
 
-        self.env['runtime']['outputManager'].presentText(attributeFormatString, soundIcon='', interrupt=True)
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/bookmark_1.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '1'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(1, 'read')

src/fenrirscreenreader/commands/commands/bookmark_10.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '10'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(10, 'read')

src/fenrirscreenreader/commands/commands/bookmark_2.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '2'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(2, 'read')

src/fenrirscreenreader/commands/commands/bookmark_3.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '3'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(3, 'read')

src/fenrirscreenreader/commands/commands/bookmark_4.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '4'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(4, 'read')

src/fenrirscreenreader/commands/commands/bookmark_5.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '5'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(5, 'read')

src/fenrirscreenreader/commands/commands/bookmark_6.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '6'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(6, 'read')

src/fenrirscreenreader/commands/commands/bookmark_7.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '7'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(7, 'read')

src/fenrirscreenreader/commands/commands/bookmark_8.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '8'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(8, 'read')

src/fenrirscreenreader/commands/commands/bookmark_9.py

@@ -4,45 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-from fenrirscreenreader.utils import mark_utils
-from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '9'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('read Bookmark {0}').format(self.ID,)
-
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-        if not self.env['commandBuffer']['bookMarks'][self.ID]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark {0} not set').format(self.ID,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1']:
-            self.env['runtime']['outputManager'].presentText(_('Bookmark for application {0} not set').format(currApp,), interrupt=True)
-            return
-
-        # set marks
-        marked = ''
-        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy()
-        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
-            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy()
-            marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
-        else:
-            x, y, marked = \
-              line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
-        if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
-        else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(9, 'read')

src/fenrirscreenreader/commands/commands/bookmark_base.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+
+from fenrirscreenreader.utils import line_utils
+from fenrirscreenreader.utils import mark_utils
+from fenrirscreenreader.core.i18n import _
+
+import gettext
+_ = gettext.gettext
+
+
+class BookmarkCommand():
+    """Base class for bookmark operations - read, set, clear"""
+
+    def __init__(self, bookmark_id, action='read'):
+        self.ID = str(bookmark_id)
+        self.action = action
+
+    def initialize(self, environment):
+        self.env = environment
+        # Always initialize bookmark structure - all commands need this
+        if self.ID not in self.env['commandBuffer']['bookMarks']:
+            self.env['commandBuffer']['bookMarks'][self.ID] = {}
+
+    def shutdown(self):
+        pass
+
+    def getDescription(self):
+        if self.action == 'read':
+            return _('read Bookmark {0}').format(self.ID)
+        elif self.action == 'set':
+            return _('set Bookmark {0}').format(self.ID)
+        elif self.action == 'clear':
+            return _('remove Bookmark {0}').format(self.ID)
+        return f'{self.action} Bookmark {self.ID}'
+
+    def run(self):
+        if self.action == 'read':
+            self._read_bookmark()
+        elif self.action == 'set':
+            self._set_bookmark()
+        elif self.action == 'clear':
+            self._clear_bookmark()
+
+    def _read_bookmark(self):
+        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
+
+        if not self.env['commandBuffer']['bookMarks'][self.ID]:
+            self.env['runtime']['outputManager'].presentText(
+                'Bookmark {0} not set'.format(self.ID), interrupt=True)
+            return
+
+        if currApp not in self.env['commandBuffer']['bookMarks'][self.ID]:
+            self.env['runtime']['outputManager'].presentText(
+                'Bookmark for application {0} not set'.format(currApp), interrupt=True)
+            return
+
+        if not self.env['commandBuffer']['bookMarks'][self.ID][currApp].get(
+                '1'):
+            self.env['runtime']['outputManager'].presentText(
+                'Bookmark for application {0} not set'.format(currApp), interrupt=True)
+            return
+
+        # Get bookmarked text
+        marked = ''
+        startMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'].copy(
+        )
+
+        if self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2']:
+            endMark = self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'].copy(
+            )
+            marked = mark_utils.getTextBetweenMarks(
+                startMark, endMark, self.env['screen']['newContentText'])
+        else:
+            x, y, marked = line_utils.getCurrentLine(
+                startMark['x'], startMark['y'], self.env['screen']['newContentText'])
+
+        if marked.isspace():
+            self.env['runtime']['outputManager'].presentText(
+                _('blank'), soundIcon='EmptyLine', interrupt=True)
+        else:
+            self.env['runtime']['outputManager'].presentText(
+                marked, interrupt=True)
+
+    def _set_bookmark(self):
+        if not self.env['commandBuffer']['Marks']['1']:
+            self.env['runtime']['outputManager'].presentText(
+                _("No mark found"), interrupt=True)
+            return
+
+        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
+        self.env['commandBuffer']['bookMarks'][self.ID][currApp] = {}
+
+        self.env['commandBuffer']['bookMarks'][self.ID][currApp]['1'] = self.env['commandBuffer']['Marks']['1'].copy()
+
+        if self.env['commandBuffer']['Marks']['2']:
+            self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'] = self.env['commandBuffer']['Marks']['2'].copy()
+        else:
+            self.env['commandBuffer']['bookMarks'][self.ID][currApp]['2'] = None
+
+        self.env['runtime']['outputManager'].presentText(
+            _('Bookmark {0} set for application {1}').format(
+                self.ID, currApp), interrupt=True)
+
+        # Clear marks after setting bookmark
+        self.env['commandBuffer']['Marks']['1'] = None
+        self.env['commandBuffer']['Marks']['2'] = None
+
+    def _clear_bookmark(self):
+        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
+
+        if self.ID in self.env['commandBuffer']['bookMarks'] and currApp in self.env['commandBuffer']['bookMarks'][self.ID]:
+            del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
+            self.env['runtime']['outputManager'].presentText(
+                _('Bookmark {0} removed for application {1}').format(
+                    self.ID, currApp), interrupt=True)
+        else:
+            self.env['runtime']['outputManager'].presentText(
+                _('Bookmark {0} not set for application {1}').format(
+                    self.ID, currApp), interrupt=True)
+
+    def setCallback(self, callback):
+        pass
+
+# Factory function to create bookmark command instances
+
+
+def create_bookmark_commands():
+    """Create all bookmark command instances"""
+    commands = {}
+
+    # Create read bookmark commands (bookmark_1 through bookmark_10)
+    for i in range(1, 11):
+        commands[f'bookmark_{i}'] = lambda i=i: BookmarkCommand(i, 'read')
+
+    # Create set bookmark commands (set_bookmark_1 through set_bookmark_10)
+    for i in range(1, 11):
+        commands[f'set_bookmark_{i}'] = lambda i=i: BookmarkCommand(i, 'set')
+
+    # Create clear bookmark commands (clear_bookmark_1 through
+    # clear_bookmark_10)
+    for i in range(1, 11):
+        commands[f'clear_bookmark_{i}'] = lambda i=i: BookmarkCommand(
+            i, 'clear')
+
+    return commands
+
+# For backwards compatibility, provide individual command classes
+# This allows the existing command loading system to work unchanged
+
+
+def _make_command_class(bookmark_id, action):
+    """Create a command class for a specific bookmark and action"""
+    class command(BookmarkCommand):
+        def __init__(self):
+            super().__init__(bookmark_id, action)
+    return command
+
+# Generate individual command classes for each bookmark operation
+# These will be used by the existing command loading system
+
+
+# Read bookmarks (bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f'bookmark_{i}_command'] = _make_command_class(i, 'read')
+
+# Set bookmarks (set_bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f'set_bookmark_{i}_command'] = _make_command_class(i, 'set')
+
+# Clear bookmarks (clear_bookmark_1.py style)
+for i in range(1, 11):
+    globals()[f'clear_bookmark_{i}_command'] = _make_command_class(i, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_1.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '1'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(1, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_10.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '10'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(10, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_2.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '2'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(2, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_3.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '3'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(3, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_4.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '4'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(4, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_5.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '5'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(5, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_6.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '6'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(6, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_7.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '7'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(7, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_8.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '8'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(8, 'clear')

src/fenrirscreenreader/commands/commands/clear_bookmark_9.py

@@ -4,24 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'bookmark_base.py')
+_spec = importlib.util.spec_from_file_location("bookmark_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+BookmarkCommand = _module.BookmarkCommand
+
+
+class command(BookmarkCommand):
     def __init__(self):
-        self.ID = '9'
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('remove Bookmark {0}').format(self.ID,)        
-    
-    def run(self):
-        currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
-
-        del self.env['commandBuffer']['bookMarks'][self.ID][currApp]
-
-        self.env['runtime']['outputManager'].presentText(_('Bookmark {0} removed for application {1}').format(self.ID, currApp), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__(9, 'clear')

src/fenrirscreenreader/commands/commands/clear_clipboard.py

@@ -4,21 +4,29 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('clears the currently selected clipboard')
 
     def run(self):
-        self.env['runtime']['memoryManager'].clearCurrentIndexList('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(_('clipboard cleared'), interrupt=True)
+        self.env['runtime']['memoryManager'].clearCurrentIndexList(
+            'clipboardHistory')
+        self.env['runtime']['outputManager'].presentText(
+            _('clipboard cleared'), interrupt=True)
         return
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/clear_window_application.py

@@ -4,24 +4,33 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Turn off window mode for application')
 
     def run(self):
         if self.env['runtime']['cursorManager'].clearWindowForApplication():
-            currApp = self.env['runtime']['applicationManager'].getCurrentApplication()    
-            self.env['runtime']['outputManager'].presentText(_('Window Mode off for application {0}').format(currApp,), interrupt=True)
+            currApp = self.env['runtime']['applicationManager'].getCurrentApplication(
+            )
+            self.env['runtime']['outputManager'].presentText(
+                _('Window Mode off for application {0}').format(
+                    currApp,), interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(_("Not in window Mode"), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("Not in window Mode"), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_last_echo_to_clipboard.py

@@ -4,16 +4,21 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('copies last presented text to the clipboard')
 
@@ -21,8 +26,10 @@ class command():
         lastEcho = self.env['runtime']['outputManager'].getLastEcho()
         if lastEcho.rstrip() != "":
             lastEcho = lastEcho.rstrip()
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', lastEcho)
-        self.env['runtime']['outputManager'].presentText(lastEcho, soundIcon='CopyToClipboard', interrupt=True)
+        self.env['runtime']['memoryManager'].addValueToFirstIndex(
+            'clipboardHistory', lastEcho)
+        self.env['runtime']['outputManager'].presentText(
+            lastEcho, soundIcon='CopyToClipboard', interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/copy_marked_to_clipboard.py

@@ -2,8 +2,11 @@
 # -*- coding: utf-8 -*-
 
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
+
+
 class command():
     def __init__(self):
         pass
@@ -53,7 +56,8 @@ class command():
 
     def run(self):
         if not self.env['commandBuffer']['Marks']['1']:
-            self.env['runtime']['outputManager'].presentText(_("One or two marks are needed"), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("One or two marks are needed"), interrupt=True)
             return
         if not self.env['commandBuffer']['Marks']['2']:
             self.env['runtime']['cursorManager'].setMark()
@@ -65,10 +69,12 @@ class command():
         # Replace mark_utils.getTextBetweenMarks with our new method
         marked = self.getTextFromScreen(startMark, endMark)
 
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', marked)
+        self.env['runtime']['memoryManager'].addValueToFirstIndex(
+            'clipboardHistory', marked)
         # reset marks
         self.env['runtime']['cursorManager'].clearMarks()
-        self.env['runtime']['outputManager'].presentText(marked, soundIcon='CopyToClipboard', interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            marked, soundIcon='CopyToClipboard', interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_clipboard.py

@@ -4,24 +4,33 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('speaks the contents of the currently selected clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard , interrupt=True)
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
+        self.env['runtime']['outputManager'].presentText(
+            clipboard, interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen.py

@@ -4,23 +4,30 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('reads the contents of the current screen')
 
     def run(self):
         if self.env['screen']['newContentText'].isspace():
-            self.env['runtime']['outputManager'].presentText(_("screen is empty"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("screen is empty"), soundIcon='EmptyLine', interrupt=True)
         else:
-           self.env['runtime']['outputManager'].presentText(self.env['screen']['newContentText'],interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                self.env['screen']['newContentText'], interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_after_cursor.py

@@ -4,16 +4,21 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('reads from the cursor to the bottom of the screen')
 
@@ -21,12 +26,15 @@ class command():
         # Prefer review cursor over text cursor
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        textAfterCursor = mark_utils.getTextAfterMark(cursorPos, self.env['screen']['newContentText'])
+        textAfterCursor = mark_utils.getTextAfterMark(
+            cursorPos, self.env['screen']['newContentText'])
 
         if textAfterCursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(textAfterCursor, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                textAfterCursor, interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/curr_screen_before_cursor.py

@@ -4,16 +4,21 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Reads from the top of the screen to the cursor position')
 
@@ -24,13 +29,15 @@ class command():
         else:
             cursorPos = self.env['screen']['newCursor'].copy()
 
-        textBeforeCursor = mark_utils.getTextBeforeMark(cursorPos, self.env['screen']['newContentText'])
+        textBeforeCursor = mark_utils.getTextBeforeMark(
+            cursorPos, self.env['screen']['newContentText'])
 
         if textBeforeCursor.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(textBeforeCursor, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                textBeforeCursor, interrupt=True)
 
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/current_quick_menu_entry.py

@@ -4,23 +4,31 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get current quick menu entry')
+
     def run(self):
         menu = ''
         value = ''
         menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
         if menu != '':
             value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                menu + ' ' + value, interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/current_quick_menu_value.py

@@ -4,19 +4,26 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get current quick menu value')
+
     def run(self):
         value = self.env['runtime']['quickMenuManager'].getCurrentValue()
         self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_column.py

@@ -4,22 +4,30 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Column number for cursor')
+
     def run(self):
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['x'] + 1) , interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            str(cursorPos['x'] + 1), interrupt=True)
         self.env['runtime']['outputManager'].announceActiveCursor()
-        self.env['runtime']['outputManager'].presentText(' column number' , interrupt=False)
+        self.env['runtime']['outputManager'].presentText(
+            ' column number', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_lineno.py

@@ -4,22 +4,30 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Line number for cursor')
+
     def run(self):
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
-        self.env['runtime']['outputManager'].presentText(str(cursorPos['y'] + 1), interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            str(cursorPos['y'] + 1), interrupt=True)
         self.env['runtime']['outputManager'].announceActiveCursor()
-        self.env['runtime']['outputManager'].presentText(' line number' , interrupt=False)
+        self.env['runtime']['outputManager'].presentText(
+            ' line number', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_position.py

@@ -4,15 +4,20 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('displays the position of the review cursor')
 
@@ -20,7 +25,12 @@ class command():
         # Prefer review cursor over text cursor
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        self.env['runtime']['outputManager'].presentText(_("line {0}, column {1}, Terminal {2}").format(cursorPos['y']+1, cursorPos['x']+1, self.env['screen']['newTTY']), interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            _("line {0}, column {1}, Terminal {2}").format(
+                cursorPos['y'] + 1,
+                cursorPos['x'] + 1,
+                self.env['screen']['newTTY']),
+            interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/cursor_read_line_to_cursor.py

@@ -4,30 +4,38 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
-        return _('read line to cursor pos, use review cursor if you are in review mode, otherwhise use text cursor')
+        return _(
+            'read line to cursor pos, use review cursor if you are in review mode, otherwhise use text cursor')
 
     def run(self):
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
+        x, y, currLine = line_utils.getCurrentLine(
+            cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
 
         if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(currLine[:cursorPos['x']], interrupt=True) 
+            self.env['runtime']['outputManager'].presentText(
+                currLine[:cursorPos['x']], interrupt=True)
         self.env['runtime']['outputManager'].announceActiveCursor()
+
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/cursor_read_to_end_of_line.py

@@ -4,30 +4,38 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
-        return _('read to end of line, use review cursor if you are in review mode, otherwhise use text cursor')        
+        return _(
+            'read to end of line, use review cursor if you are in review mode, otherwhise use text cursor')
 
     def run(self):
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
+        x, y, currLine = line_utils.getCurrentLine(
+            cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
 
         if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(currLine[cursorPos['x']:], interrupt=True) 
+            self.env['runtime']['outputManager'].presentText(
+                currLine[cursorPos['x']:], interrupt=True)
         self.env['runtime']['outputManager'].announceActiveCursor()
+
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/cycle_keyboard_layout.py

@@ -4,16 +4,22 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.core import debug
 import os
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('cycles between available keyboard layouts')
 
@@ -33,7 +39,8 @@ class command():
 
         if os.path.exists(keyboardPath):
             for file in os.listdir(keyboardPath):
-                if file.endswith('.conf') and not file.startswith('__') and not file.lower().startswith('pty'):
+                if file.endswith('.conf') and not file.startswith(
+                        '__') and not file.lower().startswith('pty'):
                     layout_name = file.replace('.conf', '')
                     if layout_name not in layouts:
                         layouts.append(layout_name)
@@ -47,11 +54,13 @@ class command():
         return layouts
 
     def run(self):
-        current_layout = self.env['runtime']['settingsManager'].getSetting('keyboard', 'keyboardLayout')
+        current_layout = self.env['runtime']['settingsManager'].getSetting(
+            'keyboard', 'keyboardLayout')
 
         # Extract layout name from full path if needed
         if '/' in current_layout:
-            current_layout = os.path.basename(current_layout).replace('.conf', '')
+            current_layout = os.path.basename(
+                current_layout).replace('.conf', '')
 
         # Get available layouts
         available_layouts = self.getAvailableLayouts()
@@ -67,7 +76,8 @@ class command():
         next_layout = available_layouts[next_index]
 
         # Update setting and reload shortcuts
-        self.env['runtime']['settingsManager'].setSetting('keyboard', 'keyboardLayout', next_layout)
+        self.env['runtime']['settingsManager'].setSetting(
+            'keyboard', 'keyboardLayout', next_layout)
 
         # Reload shortcuts with new layout
         try:

src/fenrirscreenreader/commands/commands/date.py

@@ -4,27 +4,36 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 import datetime
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('presents the date')
 
     def run(self):
-        dateFormat = self.env['runtime']['settingsManager'].getSetting('general', 'dateFormat')
+        dateFormat = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'dateFormat')
 
         # get the time formatted
-        dateString = datetime.datetime.strftime(datetime.datetime.now(), dateFormat)
+        dateString = datetime.datetime.strftime(
+            datetime.datetime.now(), dateFormat)
 
-        # present the time via speak and braile, there is no soundicon, interrupt the current speech
-        self.env['runtime']['outputManager'].presentText(dateString , soundIcon='', interrupt=True)
+        # present the time via speak and braile, there is no soundicon,
+        # interrupt the current speech
+        self.env['runtime']['outputManager'].presentText(
+            dateString, soundIcon='', interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/dec_alsa_volume.py

@@ -4,36 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-initialized = False
-try:
-    import alsaaudio
-    initialized = True
-except:
-    pass
+from fenrirscreenreader.core.i18n import _
 
-from fenrirscreenreader.core import debug
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
 
-class command():
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass
-    def getDescription(self):
-        return _("Decrease system volume")         
-
-    def run(self):
-        if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('alsaaudio is not installed'), interrupt=True) 
-           return
-        mixer = alsaaudio.Mixer()
-        value = mixer.getvolume()[0]
-        value = value - 5
-        if value < 5:
-            value = 5
-        mixer.setvolume(value)
-        self.env['runtime']['outputManager'].presentText(_("{0} percent system volume").format(value), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__('alsa', 'volume', 'dec')

src/fenrirscreenreader/commands/commands/dec_sound_volume.py

@@ -4,30 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('decrease sound volume')        
-
-    def run(self):
-        
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('sound', 'volume')
-
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.1:
-            value = 0.1  
-        self.env['runtime']['settingsManager'].setSetting('sound', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent sound volume").format(int(value * 100)), soundIcon='SoundOff', interrupt=True)
-   
-    def setCallback(self, callback):
-        pass
-
+        super().__init__('sound', 'volume', 'dec')

src/fenrirscreenreader/commands/commands/dec_speech_pitch.py

@@ -4,26 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the pitch of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'pitch')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.0:
-            value = 0.0 
-        self.env['runtime']['settingsManager'].setSetting('speech', 'pitch', str(value))   
-        self.env['runtime']['outputManager'].presentText(_('{0} percent speech pitch').format(int(value * 100)), soundIcon='', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass
+        super().__init__('speech', 'pitch', 'dec')

src/fenrirscreenreader/commands/commands/dec_speech_rate.py

@@ -4,27 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the rate of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'rate')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.0:
-            value = 0.0 
-        self.env['runtime']['settingsManager'].setSetting('speech', 'rate', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech rate").format(int(value * 100)), soundIcon='', interrupt=True)
-  
-    def setCallback(self, callback):
-        pass
+        super().__init__('speech', 'rate', 'dec')

src/fenrirscreenreader/commands/commands/dec_speech_volume.py

@@ -4,28 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Decreases the volume of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'volume')
-        value = round((math.ceil(10 * value) / 10) - 0.1, 2)
-        if value < 0.1:
-            value = 0.1  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech volume").format(int(value * 100)), soundIcon='', interrupt=True)
-
-    def setCallback(self, callback):
-        pass
-
+        super().__init__('speech', 'volume', 'dec')

src/fenrirscreenreader/commands/commands/exit_review.py

@@ -4,25 +4,32 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('exits review mode')
 
     def run(self):
         if not self.env['runtime']['cursorManager'].isReviewMode():
-            self.env['runtime']['outputManager'].presentText(_("Not in Review Mode"), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("Not in Review Mode"), interrupt=True)
             return
 
         self.env['runtime']['cursorManager'].clearReviewCursor()
-        self.env['runtime']['outputManager'].presentText(_("Exiting Review Mode"), interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            _("Exiting Review Mode"), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_file.py

@@ -4,36 +4,55 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.core import debug
 import os
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment, scriptPath=''):
         self.env = environment
 
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('export the current fenrir clipboard to a file')
+
     def run(self):
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
-        clipboardFile = open(clipboardFilePath,'w')        
+        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'clipboardExportPath')
+        clipboardFilePath = clipboardFilePath.replace(
+            '$user', self.env['general']['currUser'])
+        clipboardFilePath = clipboardFilePath.replace(
+            '$USER', self.env['general']['currUser'])
+        clipboardFilePath = clipboardFilePath.replace(
+            '$User', self.env['general']['currUser'])
+        clipboardFile = open(clipboardFilePath, 'w')
         try:
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+            if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                    'clipboardHistory'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('clipboard empty'), interrupt=True)
                 return
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')                             
+            clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+                'clipboardHistory')
             clipboardFile.write(clipboard)
             clipboardFile.close()
-            os.chmod(clipboardFilePath, 0o666)
-            self.env['runtime']['outputManager'].presentText(_('clipboard exported to file'), interrupt=True)            
+            os.chmod(clipboardFilePath, 0o644)
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard exported to file'), interrupt=True)
         except Exception as e:
-            self.env['runtime']['debug'].writeDebugOut('export_clipboard_to_file:run: Filepath:'+ clipboardFile +' trace:' + str(e),debug.debugLevel.ERROR)                                
+            self.env['runtime']['debug'].writeDebugOut(
+                'export_clipboard_to_file:run: Filepath:' +
+                clipboardFile +
+                ' trace:' +
+                str(e),
+                debug.debugLevel.ERROR)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/export_clipboard_to_x.py

@@ -4,33 +4,43 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 import os
 import importlib
 import _thread
 import pyperclip
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment, scriptPath=''):
         self.env = environment
         self.scriptPath = scriptPath
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Export current fenrir clipboard to X or GUI clipboard')
+
     def run(self):
-       _thread.start_new_thread(self._threadRun , ())
+        _thread.start_new_thread(self._threadRun, ())
+
     def _threadRun(self):
         try:
             # Check if clipboard is empty
-            if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-                self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+            if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                    'clipboardHistory'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('clipboard empty'), interrupt=True)
                 return
 
             # Get current clipboard content
-            clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+            clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+                'clipboardHistory')
 
             # Remember original display environment variable if it exists
             originalDisplay = os.environ.get('DISPLAY', '')
@@ -43,9 +53,11 @@ class command():
                     # Set display environment variable
                     os.environ['DISPLAY'] = display
                     # Attempt to set clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
+                    # Weird workaround for some distros
+                    importlib.reload(pyperclip)
                     pyperclip.copy(clipboard)
-                    # If we get here without exception, we found a working display
+                    # If we get here without exception, we found a working
+                    # display
                     success = True
                     break
                 except Exception:
@@ -60,12 +72,15 @@ class command():
 
             # Notify the user of the result
             if success:
-                self.env['runtime']['outputManager'].presentText(_('exported to the X session.'), interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    _('exported to the X session.'), interrupt=True)
             else:
-                self.env['runtime']['outputManager'].presentText(_('failed to export to X clipboard. No available display found.'), interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    _('failed to export to X clipboard. No available display found.'), interrupt=True)
 
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
+            self.env['runtime']['outputManager'].presentText(
+                str(e), soundIcon='', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/first_clipboard.py

@@ -4,25 +4,34 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('selects the first clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
         self.env['runtime']['memoryManager'].setFirstIndex('clipboardHistory')
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
+        self.env['runtime']['outputManager'].presentText(
+            clipboard, interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/forward_keypress.py

@@ -4,21 +4,27 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('sends the following keypress to the terminal or application')
 
     def run(self):
         self.env['input']['keyForeward'] = 3
-        self.env['runtime']['outputManager'].presentText(_('Forward next keypress'), interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            _('Forward next keypress'), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_file.py

@@ -4,36 +4,48 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
 import os
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('imports text from clipboard file to the clipboard')
 
     def run(self):
-        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting('general', 'clipboardExportPath')
-        clipboardFilePath = clipboardFilePath.replace('$user',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$USER',self.env['general']['currUser'])        
-        clipboardFilePath = clipboardFilePath.replace('$User',self.env['general']['currUser'])                        
+        clipboardFilePath = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'clipboardExportPath')
+        clipboardFilePath = clipboardFilePath.replace(
+            '$user', self.env['general']['currUser'])
+        clipboardFilePath = clipboardFilePath.replace(
+            '$USER', self.env['general']['currUser'])
+        clipboardFilePath = clipboardFilePath.replace(
+            '$User', self.env['general']['currUser'])
         if not os.path.exists(clipboardFilePath):
-            self.env['runtime']['outputManager'].presentText(_('File does not exist'), soundIcon='', interrupt=True)        
+            self.env['runtime']['outputManager'].presentText(
+                _('File does not exist'), soundIcon='', interrupt=True)
             return
-        clipboardFile = open(clipboardFilePath,'r') 
+        clipboardFile = open(clipboardFilePath, 'r')
         imported = clipboardFile.read()
         clipboardFile.close()
-        self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', imported)        
-
-        self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
-        self.env['runtime']['outputManager'].presentText(imported, soundIcon='', interrupt=False)        
+        self.env['runtime']['memoryManager'].addValueToFirstIndex(
+            'clipboardHistory', imported)
 
+        self.env['runtime']['outputManager'].presentText(
+            'Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            imported, soundIcon='', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/import_clipboard_from_x.py

@@ -4,24 +4,31 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 import importlib
 import _thread
 import pyperclip
 import os
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment, scriptPath=''):
         self.env = environment
         self.scriptPath = scriptPath
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _("imports the graphical clipboard to Fenrir's clipboard")
+
     def run(self):
-       _thread.start_new_thread(self._threadRun , ())
+        _thread.start_new_thread(self._threadRun, ())
+
     def _threadRun(self):
         try:
             # Remember original display environment variable if it exists
@@ -35,9 +42,11 @@ class command():
                     # Set display environment variable
                     os.environ['DISPLAY'] = display
                     # Attempt to get clipboard content
-                    importlib.reload(pyperclip) # Weird workaround for some distros
+                    # Weird workaround for some distros
+                    importlib.reload(pyperclip)
                     clipboardContent = pyperclip.paste()
-                    # If we get here without exception, we found a working display
+                    # If we get here without exception, we found a working
+                    # display
                     if clipboardContent:
                         break
                 except Exception:
@@ -52,13 +61,18 @@ class command():
 
             # Process the clipboard content if we found any
             if clipboardContent and isinstance(clipboardContent, str):
-                self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', clipboardContent)
-                self.env['runtime']['outputManager'].presentText('Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
-                self.env['runtime']['outputManager'].presentText(clipboardContent, soundIcon='', interrupt=False)
+                self.env['runtime']['memoryManager'].addValueToFirstIndex(
+                    'clipboardHistory', clipboardContent)
+                self.env['runtime']['outputManager'].presentText(
+                    'Import to Clipboard', soundIcon='CopyToClipboard', interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    clipboardContent, soundIcon='', interrupt=False)
             else:
-                self.env['runtime']['outputManager'].presentText('No text found in clipboard or no accessible display', interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    'No text found in clipboard or no accessible display', interrupt=True)
         except Exception as e:
-            self.env['runtime']['outputManager'].presentText(str(e), soundIcon='', interrupt=False)
+            self.env['runtime']['outputManager'].presentText(
+                str(e), soundIcon='', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/inc_alsa_volume.py

@@ -4,36 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-initialized = False
-try:
-    import alsaaudio
-    initialized = True
-except:
-    pass
+from fenrirscreenreader.core.i18n import _
 
-from fenrirscreenreader.core import debug
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
 
-class command():
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass
-    def getDescription(self):
-        return _("Increase system volume")         
-
-    def run(self):
-        if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('alsaaudio is not installed'), interrupt=True) 
-           return
-        mixer = alsaaudio.Mixer()
-        value = mixer.getvolume()[0]
-        value = value + 5
-        if value > 100:
-            value = 100
-        mixer.setvolume(value)
-        self.env['runtime']['outputManager'].presentText(_("{0} percent system volume").format(value), interrupt=True)
-
-    def setCallback(self, callback):
-        pass
+        super().__init__('alsa', 'volume', 'inc')

src/fenrirscreenreader/commands/commands/inc_sound_volume.py

@@ -4,29 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('adjusts the volume for in coming sounds')        
-
-    def run(self):
-        
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('sound', 'volume')
-
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('sound', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent sound volume").format(int(value * 100)),  soundIcon='SoundOn', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass
+        super().__init__('sound', 'volume', 'inc')

src/fenrirscreenreader/commands/commands/inc_speech_pitch.py

@@ -4,27 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increases the pitch of the speech')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'pitch')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'pitch', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech pitch").format(int(value * 100)), soundIcon='', interrupt=True)
-   
-    def setCallback(self, callback):
-        pass
+        super().__init__('speech', 'pitch', 'inc')

src/fenrirscreenreader/commands/commands/inc_speech_rate.py

@@ -4,27 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increase the speech rate')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'rate')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'rate', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech rate").format(int(value * 100)), soundIcon='', interrupt=True)
- 
-    def setCallback(self, callback):
-        pass
+        super().__init__('speech', 'rate', 'inc')

src/fenrirscreenreader/commands/commands/inc_speech_volume.py

@@ -4,27 +4,17 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
-import math
+from fenrirscreenreader.core.i18n import _
 
-class command():
+import os
+import importlib.util
+_base_path = os.path.join(os.path.dirname(__file__), 'adjustment_base.py')
+_spec = importlib.util.spec_from_file_location("adjustment_base", _base_path)
+_module = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_module)
+AdjustmentCommand = _module.AdjustmentCommand
+
+
+class command(AdjustmentCommand):
     def __init__(self):
-        pass
-    def initialize(self, environment):
-        self.env = environment
-    def shutdown(self):
-        pass 
-    def getDescription(self):
-        return _('Increase the speech volume')        
-    
-    def run(self):
-        value = self.env['runtime']['settingsManager'].getSettingAsFloat('speech', 'volume')
-        value = round((math.ceil(10 * value) / 10) + 0.1, 2)
-        if value > 1.0:
-            value = 1.0  
-        self.env['runtime']['settingsManager'].setSetting('speech', 'volume', str(value))   
-
-        self.env['runtime']['outputManager'].presentText(_("{0} percent speech volume").format(int(value * 100)), soundIcon='', interrupt=True)
-  
-    def setCallback(self, callback):
-        pass
+        super().__init__('speech', 'volume', 'inc')

src/fenrirscreenreader/commands/commands/indent_curr_line.py

@@ -4,16 +4,21 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Presents the indentation level for the current line')
 
@@ -24,13 +29,15 @@ class command():
             cursorPos = self.env['screen']['newCursorReview'].copy()
         else:
             cursorPos = self.env['screen']['newCursor'].copy()
-        x, y, currLine = \
-          line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
+        x, y, currLine = line_utils.getCurrentLine(
+            cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
 
         if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(_("indent {0}").format(len(currLine) - len(currLine.lstrip())), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(_("indent {0}").format(
+                len(currLine) - len(currLine.lstrip())), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/last_clipboard.py

@@ -4,25 +4,34 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('selects the last clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
         self.env['runtime']['memoryManager'].setLastIndex('clipboardHistory')
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
+        self.env['runtime']['outputManager'].presentText(
+            clipboard, interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/marked_text.py

@@ -4,35 +4,45 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import mark_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
-        return _('Presents the currently selected text that will be copied to the clipboard')        
+        return _(
+            'Presents the currently selected text that will be copied to the clipboard')
 
     def run(self):
-        if not (self.env['commandBuffer']['Marks']['1'] and \
-          self.env['commandBuffer']['Marks']['2']):
-            self.env['runtime']['outputManager'].presentText(_("please set begin and endmark"), interrupt=True)
+        if not (self.env['commandBuffer']['Marks']['1'] and
+                self.env['commandBuffer']['Marks']['2']):
+            self.env['runtime']['outputManager'].presentText(
+                _("please set begin and endmark"), interrupt=True)
             return
 
         # use the last first and the last setted mark as range
         startMark = self.env['commandBuffer']['Marks']['1'].copy()
         endMark = self.env['commandBuffer']['Marks']['2'].copy()
 
-        marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
+        marked = mark_utils.getTextBetweenMarks(
+            startMark, endMark, self.env['screen']['newContentText'])
 
         if marked.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                marked, interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_clipboard.py

@@ -4,33 +4,46 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('selects the next clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
         self.env['runtime']['memoryManager'].getNextIndex('clipboardHistory')
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
+        isFirst = self.env['runtime']['memoryManager'].isFirstIndex(
+            'clipboardHistory')
+        isLast = self.env['runtime']['memoryManager'].isLastIndex(
+            'clipboardHistory')
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
         if isFirst:
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
+            self.env['runtime']['outputManager'].presentText(
+                _('First clipboard '), interrupt=True)
         if isLast:
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
+            self.env['runtime']['outputManager'].presentText(
+                _('Last clipboard '), interrupt=True)
 
-        speechInterrupt = not(isLast or isFirst)
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
+        speechInterrupt = not (isLast or isFirst)
+        self.env['runtime']['outputManager'].presentText(
+            clipboard, interrupt=speechInterrupt)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_entry.py

@@ -4,17 +4,23 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get next quick menu entry')
+
     def run(self):
         menu = ''
         value = ''
@@ -22,8 +28,11 @@ class command():
             menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
             if menu != '':
                 value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    menu + ' ' + value, interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _('Quick menu not available'), interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/next_quick_menu_value.py

@@ -4,20 +4,28 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get next quick menu value')
+
     def run(self):
         if self.env['runtime']['quickMenuManager'].nextValue():
             value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                value, interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/paste_clipboard.py

@@ -4,26 +4,37 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 import time
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
-        self.env['runtime']['memoryManager'].addIndexList('clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt('general', 'numberOfClipboards'))
+        self.env['runtime']['memoryManager'].addIndexList(
+            'clipboardHistory', self.env['runtime']['settingsManager'].getSettingAsInt(
+                'general', 'numberOfClipboards'))
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('pastes the text from the currently selected clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
-        self.env['runtime']['outputManager'].presentText('paste clipboard', soundIcon='PasteClipboardOnScreen', interrupt=True)
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
+        self.env['runtime']['outputManager'].presentText(
+            'paste clipboard', soundIcon='PasteClipboardOnScreen', interrupt=True)
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
         self.env['runtime']['screenManager'].injectTextToScreen(clipboard)
 
     def setCallback(self, callback):

src/fenrirscreenreader/commands/commands/present_first_line.py

@@ -4,27 +4,34 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('present first line')
 
     def run(self):
-        x, y, firstLine = \
-          line_utils.getCurrentLine(0, 0, self.env['screen']['newContentText'])
+        x, y, firstLine = line_utils.getCurrentLine(
+            0, 0, self.env['screen']['newContentText'])
 
         if firstLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(firstLine, interrupt=True) 
+            self.env['runtime']['outputManager'].presentText(
+                firstLine, interrupt=True)
+
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/present_last_line.py

@@ -4,27 +4,34 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('current line')
 
     def run(self):
-        x, y, lastLine = \
-          line_utils.getCurrentLine(0, self.env['screen']['lines'] -1, self.env['screen']['newContentText'])
+        x, y, lastLine = line_utils.getCurrentLine(
+            0, self.env['screen']['lines'] - 1, self.env['screen']['newContentText'])
 
         if lastLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(lastLine, interrupt=True) 
+            self.env['runtime']['outputManager'].presentText(
+                lastLine, interrupt=True)
+
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/prev_clipboard.py

@@ -4,32 +4,45 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('selects the previous clipboard')
 
     def run(self):
-        if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
-            self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
+        if self.env['runtime']['memoryManager'].isIndexListEmpty(
+                'clipboardHistory'):
+            self.env['runtime']['outputManager'].presentText(
+                _('clipboard empty'), interrupt=True)
             return
         self.env['runtime']['memoryManager'].setPrefIndex('clipboardHistory')
-        isFirst = self.env['runtime']['memoryManager'].isFirstIndex('clipboardHistory')   
-        isLast = self.env['runtime']['memoryManager'].isLastIndex('clipboardHistory')               
-        clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')            
+        isFirst = self.env['runtime']['memoryManager'].isFirstIndex(
+            'clipboardHistory')
+        isLast = self.env['runtime']['memoryManager'].isLastIndex(
+            'clipboardHistory')
+        clipboard = self.env['runtime']['memoryManager'].getIndexListElement(
+            'clipboardHistory')
         if isFirst:
-            self.env['runtime']['outputManager'].presentText(_('First clipboard '), interrupt=True)   
+            self.env['runtime']['outputManager'].presentText(
+                _('First clipboard '), interrupt=True)
         if isLast:
-            self.env['runtime']['outputManager'].presentText(_('Last clipboard '), interrupt=True)                     
-        speechInterrupt = not(isLast or isFirst)
-        self.env['runtime']['outputManager'].presentText(clipboard, interrupt = speechInterrupt)
+            self.env['runtime']['outputManager'].presentText(
+                _('Last clipboard '), interrupt=True)
+        speechInterrupt = not (isLast or isFirst)
+        self.env['runtime']['outputManager'].presentText(
+            clipboard, interrupt=speechInterrupt)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_entry.py

@@ -4,17 +4,23 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get previous quick menu entry')
+
     def run(self):
         menu = ''
         value = ''
@@ -22,8 +28,11 @@ class command():
             menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
             if menu != '':
                 value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-                self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
+                self.env['runtime']['outputManager'].presentText(
+                    menu + ' ' + value, interrupt=True)
         else:
-            self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                _('Quick menu not available'), interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/prev_quick_menu_value.py

@@ -4,20 +4,28 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('get previous quick menu value')
+
     def run(self):
         if self.env['runtime']['quickMenuManager'].prevValue():
             value = self.env['runtime']['quickMenuManager'].getCurrentValue()
-            self.env['runtime']['outputManager'].presentText(value, interrupt=True)
+            self.env['runtime']['outputManager'].presentText(
+                value, interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/progress_bar_monitor.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+# Fenrir TTY screen reader
+# By Chrys, Storm Dragon, and contributers.
+
+from fenrirscreenreader.core.i18n import _
+
+import re
+import time
+import threading
+
+
+class command():
+    def __init__(self):
+        pass
+
+    def initialize(self, environment):
+        self.env = environment
+        # Use commandBuffer like other commands
+        if 'progressMonitoring' not in self.env['commandBuffer']:
+            # Check if progress monitoring should be enabled by default from
+            # settings
+            try:
+                defaultEnabled = self.env['runtime']['settingsManager'].getSettingAsBool(
+                    'sound', 'progressMonitoring')
+            except Exception as e:
+                # If setting doesn't exist, default to False
+                defaultEnabled = False
+            self.env['commandBuffer']['progressMonitoring'] = defaultEnabled
+            self.env['commandBuffer']['lastProgressTime'] = 0
+            self.env['commandBuffer']['lastProgressValue'] = -1
+
+    def shutdown(self):
+        self.stopProgressMonitoring()
+
+    def getDescription(self):
+        return _('Toggle progress bar monitoring with ascending tones')
+
+    def run(self):
+        # Check if commandBuffer exists
+        if 'progressMonitoring' not in self.env['commandBuffer']:
+            self.env['commandBuffer']['progressMonitoring'] = False
+            self.env['commandBuffer']['lastProgressTime'] = 0
+            self.env['commandBuffer']['lastProgressValue'] = -1
+
+        if self.env['commandBuffer']['progressMonitoring']:
+            self.stopProgressMonitoring()
+            self.env['runtime']['outputManager'].presentText(
+                _("Progress monitoring disabled"), interrupt=True)
+        else:
+            self.startProgressMonitoring()
+            self.env['runtime']['outputManager'].presentText(
+                _("Progress monitoring enabled"), interrupt=True)
+
+    def startProgressMonitoring(self):
+        self.env['commandBuffer']['progressMonitoring'] = True
+        self.env['commandBuffer']['lastProgressTime'] = time.time()
+        self.env['commandBuffer']['lastProgressValue'] = -1
+        # Don't control speech - let user decide with silence_until_prompt
+
+    def stopProgressMonitoring(self):
+        self.env['commandBuffer']['progressMonitoring'] = False
+        # Don't control speech - progress monitor is beep-only
+
+    def detectProgress(self, text):
+        if not self.env['commandBuffer']['progressMonitoring']:
+            return
+
+        # Skip progress detection if current screen looks like a prompt
+        if self.isCurrentLinePrompt():
+            return
+
+        currentTime = time.time()
+
+        # Pattern 1: Percentage (50%, 25.5%, etc.)
+        percentMatch = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
+        if percentMatch:
+            percentage = float(percentMatch.group(1))
+            if percentage != self.env['commandBuffer']['lastProgressValue']:
+                self.playProgressTone(percentage)
+                self.env['commandBuffer']['lastProgressValue'] = percentage
+                self.env['commandBuffer']['lastProgressTime'] = currentTime
+            return
+
+        # Pattern 2: Fraction (15/100, 3 of 10, etc.)
+        fractionMatch = re.search(r'(\d+)\s*(?:of|/)\s*(\d+)', text)
+        if fractionMatch:
+            current = int(fractionMatch.group(1))
+            total = int(fractionMatch.group(2))
+            if total > 0:
+                percentage = (current / total) * 100
+                if percentage != self.env['commandBuffer']['lastProgressValue']:
+                    self.playProgressTone(percentage)
+                    self.env['commandBuffer']['lastProgressValue'] = percentage
+                    self.env['commandBuffer']['lastProgressTime'] = currentTime
+                return
+
+        # Pattern 3: Progress bars ([####    ], [====>   ], etc.)
+        # Improved pattern to avoid matching IRC channels like [#channel]
+        barMatch = re.search(r'\[([#=\-\*]+)([\s\.]*)\]', text)
+        if barMatch:
+            filled = len(barMatch.group(1))
+            unfilled = len(barMatch.group(2))
+            total = filled + unfilled
+            # Require at least 2 progress chars total and unfilled portion must
+            # be spaces/dots
+            if total >= 2 and (
+                not barMatch.group(2) or re.match(
+                    r'^[\s\.]*$',
+                    barMatch.group(2))):
+                percentage = (filled / total) * 100
+                if percentage != self.env['commandBuffer']['lastProgressValue']:
+                    self.playProgressTone(percentage)
+                    self.env['commandBuffer']['lastProgressValue'] = percentage
+                    self.env['commandBuffer']['lastProgressTime'] = currentTime
+                return
+
+        # Pattern 4: Generic activity indicators (Loading..., Working..., etc.)
+        activityPattern = re.search(
+            r'(loading|processing|working|installing|downloading|compiling|building).*\.{2,}',
+            text,
+            re.IGNORECASE)
+        if activityPattern:
+            # Play a steady beep every 2 seconds for ongoing activity
+            if currentTime - \
+                    self.env['commandBuffer']['lastProgressTime'] >= 2.0:
+                self.playActivityBeep()
+                self.env['commandBuffer']['lastProgressTime'] = currentTime
+
+    def playProgressTone(self, percentage):
+        # Map 0-100% to 400-1200Hz frequency range
+        frequency = 400 + (percentage * 8)
+        frequency = max(400, min(1200, frequency))  # Clamp to safe range
+        self.env['runtime']['outputManager'].playFrequence(
+            frequency, 0.15, interrupt=False)
+
+    def playActivityBeep(self):
+        # Single tone for generic activity
+        self.env['runtime']['outputManager'].playFrequence(
+            800, 0.1, interrupt=False)
+
+    def isCurrentLinePrompt(self):
+        """Check if the current line looks like a standalone prompt (not command with progress)"""
+        import re
+
+        try:
+            # Get the current screen content
+            if not self.env['screen']['newContentText']:
+                return False
+
+            lines = self.env['screen']['newContentText'].split('\n')
+            if not lines:
+                return False
+
+            # Check the last line (most common) and current cursor line for
+            # prompt patterns
+            linesToCheck = []
+
+            # Add last line (most common for prompts)
+            if lines:
+                linesToCheck.append(lines[-1])
+
+            # Add current cursor line if different from last line
+            if (self.env['screen']['newCursor']['y'] < len(lines) and
+                    self.env['screen']['newCursor']['y'] != len(lines) - 1):
+                linesToCheck.append(
+                    lines[self.env['screen']['newCursor']['y']])
+
+            # Standalone prompt patterns (no commands mixed in)
+            standalonePromptPatterns = [
+                r'^\s*\$\s*$',  # Just $ (with whitespace)
+                r'^\s*#\s*$',   # Just # (with whitespace)
+                r'^\s*>\s*$',   # Just > (with whitespace)
+                r'^\[.*\]\s*[\\\$#>]\s*$',  # [path]$ without commands
+                r'^[a-zA-Z0-9._-]+[\\\$#>]\s*$',  # bash-5.1$ without commands
+
+                # Interactive prompt patterns (these ARE standalone)
+                r'.*\?\s*\[[YyNn]/[YyNn]\]\s*$',  # ? [Y/n] or ? [y/N] style
+                r'.*\?\s*\[[Yy]es/[Nn]o\]\s*$',  # ? [Yes/No] style
+                # "continue? [Y/n]" style
+                r'.*continue\?\s*\[[YyNn]/[YyNn]\].*$',
+                r'^::.*\?\s*\[[YyNn]/[YyNn]\].*$',  # pacman style prompts
+
+                # Authentication prompts (these ARE standalone)
+                r'^\[[Ss]udo\]\s*[Pp]assword\s*for\s+.*:\s*$',  # [sudo] password
+                r'^[Pp]assword\s*:\s*$',  # Password:
+                r'.*[Pp]assword\s*:\s*$',  # general password prompts
+
+                # Continuation prompts (these ARE standalone)
+                r'^[Pp]ress\s+any\s+key\s+to\s+continue.*$',  # Press any key
+                r'^[Aa]re\s+you\s+sure\?\s*.*$',  # Are you sure?
+            ]
+
+            for line in linesToCheck:
+                line = line.strip()
+                if not line:
+                    continue
+
+                # Check if this line contains both a prompt AND other content (like commands)
+                # If so, don't treat it as a standalone prompt
+                hasPromptMarker = bool(
+                    re.search(
+                        r'.*@.*[\\\$#>]',
+                        line) or re.search(
+                        r'^\[.*\]\s*[\\\$#>]',
+                        line))
+                if hasPromptMarker:
+                    # If line has prompt marker but also has significant content after it,
+                    # it's a command line, not a standalone prompt
+                    promptEnd = max(
+                        line.rfind('$'),
+                        line.rfind('#'),
+                        line.rfind('>'),
+                        line.rfind('\\')
+                    )
+                    if promptEnd >= 0 and promptEnd < len(
+                            line) - 5:  # More than just whitespace after prompt
+                        continue  # This is a command line, not a standalone prompt
+
+                for pattern in standalonePromptPatterns:
+                    try:
+                        if re.search(pattern, line):
+                            return True
+                    except re.error:
+                        continue
+
+            return False
+
+        except Exception as e:
+            # If anything fails, assume it's not a prompt to be safe
+            return False
+
+    def setCallback(self, callback):
+        pass

src/fenrirscreenreader/commands/commands/quit_fenrir.py

@@ -4,15 +4,20 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('exits Fenrir')
 
@@ -21,4 +26,3 @@ class command():
 
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/remove_marks.py

@@ -4,21 +4,27 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Removes marks from selected text')
 
     def run(self):
         self.env['runtime']['cursorManager'].clearMarks()
-        self.env['runtime']['outputManager'].presentText(_('Remove marks'), interrupt=True)
+        self.env['runtime']['outputManager'].presentText(
+            _('Remove marks'), interrupt=True)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/remove_word_from_spell_check.py

@@ -4,52 +4,71 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import word_utils
 import string
 initialized = False
 try:
     import enchant
     initialized = True
-except:
+except Exception as e:
     pass
 
+
 class command():
     def __init__(self):
         self.language = ''
         self.spellChecker = None
+
     def initialize(self, environment):
         self.env = environment
         self.updateSpellLanguage()
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('removes the current word from the exceptions dictionary')
+
     def updateSpellLanguage(self):
-        self.spellChecker = enchant.Dict(self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage'))
-        self.language = self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage')      
+        self.spellChecker = enchant.Dict(
+            self.env['runtime']['settingsManager'].getSetting(
+                'general', 'spellCheckLanguage'))
+        self.language = self.env['runtime']['settingsManager'].getSetting(
+            'general', 'spellCheckLanguage')
 
     def run(self):
         if not initialized:
-           self.env['runtime']['outputManager'].presentText(_('pyenchant is not installed'), interrupt=True) 
-           return
-        if self.env['runtime']['settingsManager'].getSetting('general', 'spellCheckLanguage') != self.language:
+            self.env['runtime']['outputManager'].presentText(
+                _('pyenchant is not installed'), interrupt=True)
+            return
+        if self.env['runtime']['settingsManager'].getSetting(
+                'general', 'spellCheckLanguage') != self.language:
             try:
                 self.updateSpellLanguage()
-            except:
+            except Exception as e:
                 return
 
         cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
 
         # get the word
-        newContent = self.env['screen']['newContentText'].split('\n')[cursorPos['y']]
-        x, y, currWord, endOfScreen, lineBreak =  word_utils.getCurrentWord(cursorPos['x'], 0, newContent)                  
-        currWord = currWord.strip(string.whitespace + r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
+        newContent = self.env['screen']['newContentText'].split('\n')[
+            cursorPos['y']]
+        x, y, currWord, endOfScreen, lineBreak = word_utils.getCurrentWord(
+            cursorPos['x'], 0, newContent)
+        currWord = currWord.strip(
+            string.whitespace +
+            r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
         if not currWord.isspace():
             if self.spellChecker.is_removed(currWord):
-                self.env['runtime']['outputManager'].presentText(_('{0} is not in the dictionary').format(currWord,), soundIcon='Cancel', interrupt=True)                
+                self.env['runtime']['outputManager'].presentText(
+                    _('{0} is not in the dictionary').format(
+                        currWord,), soundIcon='Cancel', interrupt=True)
             else:
                 self.spellChecker.remove(currWord)
-                self.env['runtime']['outputManager'].presentText(_('{0} removed').format(currWord,), soundIcon='Accept', interrupt=True)                    
+                self.env['runtime']['outputManager'].presentText(
+                    _('{0} removed').format(currWord,), soundIcon='Accept', interrupt=True)
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_bottom.py

@@ -4,21 +4,28 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+
+from fenrirscreenreader.core.i18n import _
+
 
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Move review to the bottom of the screen')
 
     def run(self):
-        self.env['screen']['newCursorReview'] = { 'x': 0, 'y':self.env['screen']['lines'] -1}
-        self.env['runtime']['outputManager'].presentText(_("Bottom"), interrupt=True, flush=False)
+        self.env['screen']['newCursorReview'] = {
+            'x': 0, 'y': self.env['screen']['lines'] - 1}
+        self.env['runtime']['outputManager'].presentText(
+            _("Bottom"), interrupt=True, flush=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char.py

@@ -4,33 +4,46 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import char_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('presents the current character.')
 
     def run(self):
         self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = char_utils.getCurrentChar(
+            self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
-        self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
+        char_utils.presentCharForReview(
+            self.env,
+            currChar,
+            interrupt=True,
+            announceCapital=True,
+            flush=False)
         # is has attribute it enabled?
-        if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
+        if self.env['runtime']['settingsManager'].getSettingAsBool(
+                'general', 'hasAttributes'):
             cursorPos = self.env['screen']['newCursorReview']
 
-            if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
+            if not self.env['runtime']['attributeManager'].hasAttributes(
+                    cursorPos):
                 return
-            self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)        
+            self.env['runtime']['outputManager'].presentText(
+                'has attribute', soundIcon='HasAttributes', interrupt=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_char_phonetic.py

@@ -4,30 +4,37 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import char_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('set review and phonetically presents the current character')
 
     def run(self):
         self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = \
-          char_utils.getCurrentChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currChar = char_utils.getCurrentChar(
+            self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
         if currChar.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), interrupt=True, flush=False)
         else:
             currChar = char_utils.getPhonetic(currChar)
-            self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, announceCapital=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                currChar, interrupt=True, announceCapital=True, flush=False)
 
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_line.py

@@ -4,29 +4,36 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import line_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('current line')
 
     def run(self):
         self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currLine = \
-          line_utils.getCurrentLine(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currLine = line_utils.getCurrentLine(
+            self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
         if currLine.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
         else:
-            self.env['runtime']['outputManager'].presentText(currLine, interrupt=True, flush=False) 
+            self.env['runtime']['outputManager'].presentText(
+                currLine, interrupt=True, flush=False)
+
     def setCallback(self, callback):
         pass
-

src/fenrirscreenreader/commands/commands/review_curr_word.py

@@ -4,34 +4,46 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import word_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
-            return _('current word.')        
+        return _('current word.')
 
     def run(self):
         self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
 
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = word_utils.getCurrentWord(
+            self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
         if currWord.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), interrupt=True, flush=False)
         else:
-            self.env['runtime']['outputManager'].presentText(currWord, interrupt=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                currWord, interrupt=True, flush=False)
         if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')
+            if self.env['runtime']['settingsManager'].getSettingAsBool(
+                    'review', 'endOfScreen'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('end of screen'), interrupt=True, soundIcon='EndOfScreen')
         if lineBreak:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
+            if self.env['runtime']['settingsManager'].getSettingAsBool(
+                    'review', 'lineBreak'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('line break'), interrupt=False, soundIcon='EndOfLine')
+
     def setCallback(self, callback):
         pass

src/fenrirscreenreader/commands/commands/review_curr_word_phonetic.py

@@ -4,38 +4,50 @@
 # Fenrir TTY screen reader
 # By Chrys, Storm Dragon, and contributers.
 
-from fenrirscreenreader.core import debug
+from fenrirscreenreader.core.i18n import _
+
 from fenrirscreenreader.utils import word_utils
 from fenrirscreenreader.utils import char_utils
 
+
 class command():
     def __init__(self):
         pass
+
     def initialize(self, environment):
         self.env = environment
+
     def shutdown(self):
         pass
+
     def getDescription(self):
         return _('Phonetically spells the current word')
 
     def run(self):
         self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
-        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = \
-          word_utils.getCurrentWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
+        self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], currWord, endOfScreen, lineBreak = word_utils.getCurrentWord(
+            self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
 
         if currWord.isspace():
-            self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
+            self.env['runtime']['outputManager'].presentText(
+                _("blank"), interrupt=True, flush=False)
         else:
             firstSequence = True
             for c in currWord:
                 currChar = char_utils.getPhonetic(c)
-                self.env['runtime']['outputManager'].presentText(currChar, interrupt=firstSequence, announceCapital=True, flush=False)
+                self.env['runtime']['outputManager'].presentText(
+                    currChar, interrupt=firstSequence, announceCapital=True, flush=False)
                 firstSequence = False
         if endOfScreen:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):        
-                self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=True, soundIcon='EndOfScreen')                 
+            if self.env['runtime']['settingsManager'].getSettingAsBool(
+                    'review', 'endOfScreen'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('end of screen'), interrupt=True, soundIcon='EndOfScreen')
         if lineBreak:
-            if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):        
-                self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')   
+            if self.env['runtime']['settingsManager'].getSettingAsBool(
+                    'review', 'lineBreak'):
+                self.env['runtime']['outputManager'].presentText(
+                    _('line break'), interrupt=False, soundIcon='EndOfLine')
+
     def setCallback(self, callback):
         pass