storm/fenrir
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge after mostly converting to pep8 compliance.

Browse Source
This commit is contained in:
Storm Dragon
2025-07-06 18:34:28 -04:00
parent 23c3ad20a1 d28c18faed
commit 1268d989b7
347 changed files with 12289 additions and 7411 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/fenrir
View File

@ -27,7 +27,7 @@ def create_argument_parser():
argumentParser.add_argument(
'-v', '--version',
action='version',
version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.codeName}',
version=f'Fenrir screen reader version {fenrirVersion.version}-{fenrirVersion.code_name}',
help='Show version information and exit'
)
argumentParser.add_argument(
@ -94,9 +94,18 @@ def validate_arguments(cliArgs):
def run_fenrir():
"""Main function that runs Fenrir"""
fenrirApp = fenrirManager.fenrirManager(cliArgs)
fenrirApp.proceed()
del fenrirApp
fenrirApp = fenrirManager.FenrirManager(cliArgs)
try:
fenrirApp.proceed()
finally:
del fenrirApp
# Clean up PID file if it exists
pidFile = "/run/fenrir.pid"
if os.path.exists(pidFile):
try:
os.remove(pidFile)
except Exception:
pass
def main():
global cliArgs

14
src/fenrirscreenreader/commands/command_template.py
View File

@ -5,16 +5,24 @@
# By Chrys, Storm Dragon, and contributers.
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 get_description(self):
return 'No description found'
def run(self):
pass
def setCallback(self, callback):
def set_callback(self, callback):
pass

21
src/fenrirscreenreader/commands/commands/00_init_commands.py
View File

@ -6,20 +6,31 @@
# this command is just to initialize stuff.
# like init index lists in memoryManager
# 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'].add_index_list(
'clipboardHistory', self.env['runtime']['SettingsManager'].get_setting_as_int(
'general', 'numberOfClipboards'))
def shutdown(self):
pass
def getDescription(self):
return 'No description found'
def get_description(self):
return 'No description found'
def run(self):
pass
def setCallback(self, callback):
def set_callback(self, callback):
pass

65
src/fenrirscreenreader/commands/commands/add_word_to_spell_check.py
View File

@ -4,6 +4,8 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
from fenrirscreenreader.utils import word_utils
import string
initialized = False
@ -12,42 +14,59 @@ try:
initialized = True
except Exception as e:
pass
class command():
def __init__(self):
self.language = ''
self.spellChecker = None
def initialize(self, environment):
self.env = environment
self.updateSpellLanguage()
self.update_spell_language()
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')
pass
def get_description(self):
return _('adds the current word to the exceptions dictionary')
def update_spell_language(self):
self.spellChecker = enchant.Dict(
self.env['runtime']['SettingsManager'].get_setting(
'general', 'spellCheckLanguage'))
self.language = self.env['runtime']['SettingsManager'].get_setting(
'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'].get_setting(
'general', 'spellCheckLanguage') != self.language:
try:
self.updateSpellLanguage()
self.update_spell_language()
except Exception as e:
return
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
return
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
# 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'!"#$%&\()*+,-./:;<=Â?@[\\]^_{|}~')
new_content = self.env['screen']['new_content_text'].split('\n')[
cursor_pos['y']]
x, y, curr_word, end_of_screen, line_break = word_utils.get_current_word(
cursor_pos['x'], 0, new_content)
curr_word = curr_word.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)
if curr_word != '':
if self.spellChecker.is_added(curr_word):
self.env['runtime']['OutputManager'].present_text(
_('{0} is already in dictionary').format(
curr_word,), sound_icon ='Cancel', interrupt=True)
else:
self.spellChecker.add(currWord)
self.env['runtime']['outputManager'].presentText(_('{0} added to dictionary').format(currWord,), soundIcon='Accept', interrupt=True)
self.spellChecker.add(curr_word)
self.env['runtime']['OutputManager'].present_text(
_('{0} added to dictionary').format(
curr_word,), sound_icon ='Accept', interrupt=True)
def setCallback(self, callback):
def set_callback(self, callback):
pass

64
src/fenrirscreenreader/commands/commands/adjustment_base.py
View File

@ -4,29 +4,33 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
import math
class AdjustmentCommand():
class adjustment_command():
"""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):
def get_description(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
@ -34,11 +38,12 @@ class AdjustmentCommand():
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)
value = self.env['runtime']['SettingsManager'].get_setting_as_float(
self.section, self.setting)
# Apply adjustment with rounding
if self.direction == 'inc':
value = round((math.ceil(10 * value) / 10) + self.step, 2)
@ -48,23 +53,28 @@ class AdjustmentCommand():
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))
self.env['runtime']['SettingsManager'].set_setting(
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)
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)
feedback = _("{0} percent {1} {2}").format(
percentage, self.section, self.setting)
self.env['runtime']['OutputManager'].present_text(
feedback, sound_icon ='', 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)
value = self.env['runtime']['SettingsManager'].get_setting_as_float(
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)
@ -74,15 +84,17 @@ class AdjustmentCommand():
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))
self.env['runtime']['SettingsManager'].set_setting(
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
self.env['runtime']['OutputManager'].present_text(
feedback, sound_icon =sound_icon, interrupt=True)
def set_callback(self, callback):
pass

26
src/fenrirscreenreader/commands/commands/announce_fenrir_version.py
View File

@ -4,23 +4,33 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 get_description(self):
return _('Present the version of Fenrir currently 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)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
f'Fenrir screen reader version {
fenrirVersion.version}-{
fenrirVersion.code_name}', interrupt=True)
except Exception as e:
self.env['runtime']['OutputManager'].present_text(
_('Version information is unavailable.'), interrupt=True)
def set_callback(self, callback):
pass

103
src/fenrirscreenreader/commands/commands/apply_tested_voice.py
View File

@ -1,71 +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):
def get_description(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
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)
'lastTestedVoice' not in self.env['commandBuffer']):
self.env['runtime']['OutputManager'].present_text(
"No voice has been tested yet", interrupt=True)
self.env['runtime']['OutputManager'].present_text(
"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)
self.env['runtime']['OutputManager'].present_text(
f"Applying {voice} from {module}", interrupt=True)
# Apply to runtime settings only (temporary until saved)
settingsManager = self.env['runtime']['settingsManager']
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')
old_driver = SettingsManager.get_setting('speech', 'driver')
old_module = SettingsManager.get_setting('speech', 'module')
old_voice = SettingsManager.get_setting('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 new settings to runtime only (use set_setting to update
# settingArgDict)
SettingsManager.set_setting('speech', 'driver', 'speechdDriver')
SettingsManager.set_setting('speech', 'module', module)
SettingsManager.set_setting('speech', 'voice', voice)
# Apply to speech driver instance directly
if 'speechDriver' in self.env['runtime']:
speechDriver = self.env['runtime']['speechDriver']
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')
SpeechDriver.set_module(module)
SpeechDriver.set_voice(voice)
self.env['runtime']['OutputManager'].present_text(
"Voice applied successfully!", interrupt=True)
self.env['runtime']['OutputManager'].present_text(
"Use save settings to make permanent", interrupt=True)
self.env['runtime']['OutputManager'].play_sound('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')
SettingsManager.set_setting('speech', 'driver', old_driver)
SettingsManager.set_setting('speech', 'module', old_module)
SettingsManager.set_setting('speech', 'voice', old_voice)
self.env['runtime']['OutputManager'].present_text(
f"Failed to apply voice, reverted: {str(e)}", interrupt=True)
self.env['runtime']['OutputManager'].play_sound('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
self.env['runtime']['OutputManager'].present_text(
f"Apply voice error: {str(e)}", interrupt=True)
self.env['runtime']['OutputManager'].play_sound('Error')
def set_callback(self, callback):
pass

32
src/fenrirscreenreader/commands/commands/attribute_cursor.py
View File

@ -4,26 +4,38 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 get_description(self):
return _('Reads attributes of current cursor position')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
try:
attributes = self.env['runtime']['attributeManager'].getAttributeByXY( cursorPos['x'], cursorPos['y'])
attributes = self.env['runtime']['AttributeManager'].get_attribute_by_xy(
cursor_pos['x'], cursor_pos['y'])
except Exception as e:
print(e)
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)
def setCallback(self, callback):
print(e)
attribute_format_string = self.env['runtime']['SettingsManager'].get_setting(
'general', 'attribute_format_string')
attribute_format_string = self.env['runtime']['AttributeManager'].format_attributes(
attributes, attribute_format_string)
self.env['runtime']['OutputManager'].present_text(
attribute_format_string, sound_icon ='', interrupt=True)
def set_callback(self, callback):
pass

7
src/fenrirscreenreader/commands/commands/bookmark_1.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(1, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_10.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(10, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_2.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(2, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_3.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(3, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_4.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(4, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_5.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(5, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_6.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(6, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_7.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(7, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_8.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(8, 'read')

7
src/fenrirscreenreader/commands/commands/bookmark_9.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(9, 'read')

146
src/fenrirscreenreader/commands/commands/bookmark_base.py
View File

@ -4,28 +4,31 @@
# 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
from fenrirscreenreader.utils import mark_utils
from fenrirscreenreader.utils import line_utils
class BookmarkCommand():
class bookmark_command():
"""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):
def get_description(self):
if self.action == 'read':
return _('read Bookmark {0}').format(self.ID)
elif self.action == 'set':
@ -33,7 +36,7 @@ class BookmarkCommand():
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()
@ -41,95 +44,117 @@ class BookmarkCommand():
self._set_bookmark()
elif self.action == 'clear':
self._clear_bookmark()
def _read_bookmark(self):
currApp = self.env['runtime']['applicationManager'].getCurrentApplication()
curr_app = self.env['runtime']['ApplicationManager'].get_current_application()
if not self.env['commandBuffer']['bookMarks'][self.ID]:
self.env['runtime']['outputManager'].presentText('Bookmark {0} not set'.format(self.ID), interrupt=True)
self.env['runtime']['OutputManager'].present_text(
'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)
if curr_app not in self.env['commandBuffer']['bookMarks'][self.ID]:
self.env['runtime']['OutputManager'].present_text(
'Bookmark for application {0} not set'.format(curr_app), 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)
if not self.env['commandBuffer']['bookMarks'][self.ID][curr_app].get(
'1'):
self.env['runtime']['OutputManager'].present_text(
'Bookmark for application {0} not set'.format(curr_app), 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'])
start_mark = self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['1'].copy(
)
if self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['2']:
end_mark = self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['2'].copy(
)
marked = mark_utils.get_text_between_marks(
start_mark, end_mark, self.env['screen']['new_content_text'])
else:
x, y, marked = line_utils.getCurrentLine(startMark['x'], startMark['y'], self.env['screen']['newContentText'])
x, y, marked = line_utils.get_current_line(
start_mark['x'], start_mark['y'], self.env['screen']['new_content_text'])
if marked.isspace():
self.env['runtime']['outputManager'].presentText(_('blank'), soundIcon='EmptyLine', interrupt=True)
self.env['runtime']['OutputManager'].present_text(
_('blank'), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
self.env['runtime']['OutputManager'].present_text(
marked, interrupt=True)
def _set_bookmark(self):
if not self.env['commandBuffer']['Marks']['1']:
self.env['runtime']['outputManager'].presentText(_("No mark found"), interrupt=True)
self.env['runtime']['OutputManager'].present_text(
_("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()
curr_app = self.env['runtime']['ApplicationManager'].get_current_application()
self.env['commandBuffer']['bookMarks'][self.ID][curr_app] = {}
self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['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()
self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['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)
self.env['commandBuffer']['bookMarks'][self.ID][curr_app]['2'] = None
self.env['runtime']['OutputManager'].present_text(
_('Bookmark {0} set for application {1}').format(
self.ID, curr_app), 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)
curr_app = self.env['runtime']['ApplicationManager'].get_current_application()
if self.ID in self.env['commandBuffer']['bookMarks'] and curr_app in self.env['commandBuffer']['bookMarks'][self.ID]:
del self.env['commandBuffer']['bookMarks'][self.ID][curr_app]
self.env['runtime']['OutputManager'].present_text(
_('Bookmark {0} removed for application {1}').format(
self.ID, curr_app), 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):
self.env['runtime']['OutputManager'].present_text(
_('Bookmark {0} not set for application {1}').format(
self.ID, curr_app), interrupt=True)
def set_callback(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')
commands[f'bookmark_{i}'] = lambda i=i: bookmark_command(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)
commands[f'set_bookmark_{i}'] = lambda i=i: bookmark_command(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')
commands[f'clear_bookmark_{i}'] = lambda i=i: bookmark_command(
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):
class command(bookmark_command):
def __init__(self):
super().__init__(bookmark_id, action)
return command
@ -137,14 +162,15 @@ def _make_command_class(bookmark_id, action):
# 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)
# 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')
globals()[f'clear_bookmark_{i}_command'] = _make_command_class(i, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_1.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(1, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_10.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(10, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_2.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(2, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_3.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(3, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_4.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(4, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_5.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(5, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_6.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(6, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_7.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(7, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_8.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(8, 'clear')

7
src/fenrirscreenreader/commands/commands/clear_bookmark_9.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
bookmark_command = _module.bookmark_command
class command(BookmarkCommand):
class command(bookmark_command):
def __init__(self):
super().__init__(9, 'clear')

23
src/fenrirscreenreader/commands/commands/clear_clipboard.py
View File

@ -5,19 +5,28 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(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)
return
def setCallback(self, callback):
self.env['runtime']['MemoryManager'].clear_current_index_list(
'clipboardHistory')
self.env['runtime']['OutputManager'].present_text(
_('clipboard cleared'), interrupt=True)
return
def set_callback(self, callback):
pass

34
src/fenrirscreenreader/commands/commands/clear_window_application.py
View File

@ -5,22 +5,32 @@
# By Chrys, Storm Dragon, and contributers.
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)
else:
self.env['runtime']['outputManager'].presentText(_("Not in window Mode"), interrupt=True)
def setCallback(self, callback):
pass
def get_description(self):
return _('Turn off window mode for application')
def run(self):
if self.env['runtime']['CursorManager'].clear_window_for_application():
curr_app = self.env['runtime']['ApplicationManager'].get_current_application(
)
self.env['runtime']['OutputManager'].present_text(
_('Window Mode off for application {0}').format(
curr_app,), interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
_("Not in window Mode"), interrupt=True)
def set_callback(self, callback):
pass

32
src/fenrirscreenreader/commands/commands/copy_last_echo_to_clipboard.py
View File

@ -4,24 +4,32 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
def run(self):
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)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('copies last presented text to the clipboard')
def run(self):
last_echo = self.env['runtime']['OutputManager'].get_last_echo()
if last_echo.rstrip() != "":
last_echo = last_echo.rstrip()
self.env['runtime']['MemoryManager'].add_value_to_first_index(
'clipboardHistory', last_echo)
self.env['runtime']['OutputManager'].present_text(
last_echo, sound_icon ='CopyToClipboard', interrupt=True)
def set_callback(self, callback):
pass

103
src/fenrirscreenreader/commands/commands/copy_marked_to_clipboard.py
View File

@ -2,72 +2,79 @@
# -*- coding: utf-8 -*-
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 marked text to the currently selected clipboard')
def getTextFromScreen(self, startMark, endMark):
screenContent = self.env['screen']['newContentText']
screenLines = screenContent.split('\n')
startY = min(startMark['y'], len(screenLines) - 1)
endY = min(endMark['y'], len(screenLines) - 1)
pass
def get_description(self):
return _('copies marked text to the currently selected clipboard')
def get_text_from_screen(self, start_mark, end_mark):
screen_content = self.env['screen']['new_content_text']
screen_lines = screen_content.split('\n')
start_y = min(start_mark['y'], len(screen_lines) - 1)
end_y = min(end_mark['y'], len(screen_lines) - 1)
# If marks are on the same line
if startY == endY:
line = screenLines[startY]
startX = min(startMark['x'], len(line))
endX = min(endMark['x'], len(line)) + 1
return line[startX:endX]
if start_y == end_y:
line = screen_lines[start_y]
start_x = min(start_mark['x'], len(line))
end_x = min(end_mark['x'], len(line)) + 1
return line[start_x:end_x]
# Handle multi-line selection
result = []
# First line (from start mark to end of line)
firstLine = screenLines[startY]
startX = min(startMark['x'], len(firstLine))
result.append(firstLine[startX:].rstrip())
first_line = screen_lines[start_y]
start_x = min(start_mark['x'], len(first_line))
result.append(first_line[start_x:].rstrip())
# Middle lines (complete lines)
for lineNum in range(startY + 1, endY):
result.append(screenLines[lineNum].rstrip())
for lineNum in range(start_y + 1, end_y):
result.append(screen_lines[lineNum].rstrip())
# Last line (from start to end mark)
if endY > startY:
lastLine = screenLines[endY]
endX = min(endMark['x'], len(lastLine)) + 1
result.append(lastLine[:endX].rstrip())
if end_y > start_y:
last_line = screen_lines[end_y]
end_x = min(end_mark['x'], len(last_line)) + 1
result.append(last_line[:end_x].rstrip())
return '\n'.join(result)
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'].present_text(
_("One or two marks are needed"), interrupt=True)
return
if not self.env['commandBuffer']['Marks']['2']:
self.env['runtime']['cursorManager'].setMark()
self.env['runtime']['CursorManager'].set_mark()
# 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()
# Replace mark_utils.getTextBetweenMarks with our new method
marked = self.getTextFromScreen(startMark, endMark)
self.env['runtime']['memoryManager'].addValueToFirstIndex('clipboardHistory', marked)
start_mark = self.env['commandBuffer']['Marks']['1'].copy()
end_mark = self.env['commandBuffer']['Marks']['2'].copy()
# Replace mark_utils.get_text_between_marks with our new method
marked = self.get_text_from_screen(start_mark, end_mark)
self.env['runtime']['MemoryManager'].add_value_to_first_index(
'clipboardHistory', marked)
# reset marks
self.env['runtime']['cursorManager'].clearMarks()
self.env['runtime']['outputManager'].presentText(marked, soundIcon='CopyToClipboard', interrupt=True)
def setCallback(self, callback):
self.env['runtime']['CursorManager'].clear_marks()
self.env['runtime']['OutputManager'].present_text(
marked, sound_icon ='CopyToClipboard', interrupt=True)
def set_callback(self, callback):
pass

30
src/fenrirscreenreader/commands/commands/curr_clipboard.py
View File

@ -5,22 +5,32 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(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)
return
clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
self.env['runtime']['outputManager'].presentText(clipboard , interrupt=True)
def setCallback(self, callback):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
self.env['runtime']['OutputManager'].present_text(
clipboard, interrupt=True)
def set_callback(self, callback):
pass

26
src/fenrirscreenreader/commands/commands/curr_screen.py
View File

@ -5,21 +5,29 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(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)
else:
self.env['runtime']['outputManager'].presentText(self.env['screen']['newContentText'],interrupt=True)
def setCallback(self, callback):
if self.env['screen']['new_content_text'].isspace():
self.env['runtime']['OutputManager'].present_text(
_("screen is empty"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
self.env['screen']['new_content_text'], interrupt=True)
def set_callback(self, callback):
pass

27
src/fenrirscreenreader/commands/commands/curr_screen_after_cursor.py
View File

@ -4,28 +4,37 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
return _('reads from the cursor to the bottom of the screen')
def run(self):
# Prefer review cursor over text cursor
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
textAfterCursor = mark_utils.getTextAfterMark(cursorPos, self.env['screen']['newContentText'])
text_after_cursor = mark_utils.get_text_after_mark(
cursor_pos, self.env['screen']['new_content_text'])
if textAfterCursor.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
if text_after_cursor.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(textAfterCursor, interrupt=True)
self.env['runtime']['OutputManager'].present_text(
text_after_cursor, interrupt=True)
def setCallback(self, callback):
def set_callback(self, callback):
pass

32
src/fenrirscreenreader/commands/commands/curr_screen_before_cursor.py
View File

@ -4,32 +4,40 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
return _('Reads from the top of the screen to the cursor position')
def run(self):
# Prefer review cursor over text cursor
if self.env['screen']['newCursorReview']:
cursorPos = self.env['screen']['newCursorReview'].copy()
cursor_pos = self.env['screen']['newCursorReview'].copy()
else:
cursorPos = self.env['screen']['newCursor'].copy()
cursor_pos = self.env['screen']['new_cursor'].copy()
textBeforeCursor = mark_utils.getTextBeforeMark(cursorPos, self.env['screen']['newContentText'])
text_before_cursor = mark_utils.get_text_before_mark(
cursor_pos, self.env['screen']['new_content_text'])
if textBeforeCursor.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
if text_before_cursor.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(textBeforeCursor, interrupt=True)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
text_before_cursor, interrupt=True)
def set_callback(self, callback):
pass

21
src/fenrirscreenreader/commands/commands/current_quick_menu_entry.py
View File

@ -5,21 +5,30 @@
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(self):
return _('get current quick menu entry')
def run(self):
menu = ''
value = ''
menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
menu = self.env['runtime']['QuickMenuManager'].get_current_entry()
if menu != '':
value = self.env['runtime']['quickMenuManager'].getCurrentValue()
self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
def setCallback(self, callback):
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(
menu + ' ' + value, interrupt=True)
def set_callback(self, callback):
pass

22
src/fenrirscreenreader/commands/commands/current_quick_menu_value.py
View File

@ -5,17 +5,25 @@
# By Chrys, Storm Dragon, and contributers.
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
def get_description(self):
return _('get current quick menu value')
def run(self):
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(value, interrupt=True)
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/cursor_column.py
View File

@ -5,20 +5,29 @@
# By Chrys, Storm Dragon, and contributers.
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 get_description(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'].announceActiveCursor()
self.env['runtime']['outputManager'].presentText(' column number' , interrupt=False)
def setCallback(self, callback):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['runtime']['OutputManager'].present_text(
str(cursor_pos['x'] + 1), interrupt=True)
self.env['runtime']['OutputManager'].announce_active_cursor()
self.env['runtime']['OutputManager'].present_text(
' column number', interrupt=False)
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/cursor_lineno.py
View File

@ -5,20 +5,29 @@
# By Chrys, Storm Dragon, and contributers.
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 get_description(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'].announceActiveCursor()
self.env['runtime']['outputManager'].presentText(' line number' , interrupt=False)
def setCallback(self, callback):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['runtime']['OutputManager'].present_text(
str(cursor_pos['y'] + 1), interrupt=True)
self.env['runtime']['OutputManager'].announce_active_cursor()
self.env['runtime']['OutputManager'].present_text(
' line number', interrupt=False)
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/cursor_position.py
View File

@ -5,21 +5,32 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
return _('displays the position of the review cursor')
def run(self):
# Prefer review cursor over text cursor
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
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):
self.env['runtime']['OutputManager'].present_text(
_("line {0}, column {1}, Terminal {2}").format(
cursor_pos['y'] + 1,
cursor_pos['x'] + 1,
self.env['screen']['newTTY']),
interrupt=True)
def set_callback(self, callback):
pass

41
src/fenrirscreenreader/commands/commands/cursor_read_line_to_cursor.py
View File

@ -4,29 +4,38 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
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)
else:
self.env['runtime']['outputManager'].presentText(currLine[:cursorPos['x']], interrupt=True)
self.env['runtime']['outputManager'].announceActiveCursor()
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _(
'read line to cursor pos, use review cursor if you are in review mode, otherwhise use text cursor')
def run(self):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
x, y, curr_line = line_utils.get_current_line(
cursor_pos['x'], cursor_pos['y'], self.env['screen']['new_content_text'])
if curr_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
curr_line[:cursor_pos['x']], interrupt=True)
self.env['runtime']['OutputManager'].announce_active_cursor()
def set_callback(self, callback):
pass

41
src/fenrirscreenreader/commands/commands/cursor_read_to_end_of_line.py
View File

@ -4,29 +4,38 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
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)
else:
self.env['runtime']['outputManager'].presentText(currLine[cursorPos['x']:], interrupt=True)
self.env['runtime']['outputManager'].announceActiveCursor()
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _(
'read to end of line, use review cursor if you are in review mode, otherwhise use text cursor')
def run(self):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
x, y, curr_line = line_utils.get_current_line(
cursor_pos['x'], cursor_pos['y'], self.env['screen']['new_content_text'])
if curr_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
curr_line[cursor_pos['x']:], interrupt=True)
self.env['runtime']['OutputManager'].announce_active_cursor()
def set_callback(self, callback):
pass

86
src/fenrirscreenreader/commands/commands/cycle_keyboard_layout.py
View File

@ -4,58 +4,67 @@
# 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):
pass
def get_description(self):
return _('cycles between available keyboard layouts')
def getAvailableLayouts(self):
def get_available_layouts(self):
"""Get list of available keyboard layout files"""
layouts = []
# Check standard locations for keyboard layouts
settingsRoot = '/etc/fenrirscreenreader/'
if not os.path.exists(settingsRoot):
settings_root = '/etc/fenrirscreenreader/'
if not os.path.exists(settings_root):
# Fallback to source directory
import fenrirscreenreader
fenrirPath = os.path.dirname(fenrirscreenreader.__file__)
settingsRoot = fenrirPath + '/../../config/'
keyboardPath = settingsRoot + 'keyboard/'
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'):
fenrir_path = os.path.dirname(fenrirscreenreader.__file__)
settings_root = fenrir_path + '/../../config/'
keyboard_path = settings_root + 'keyboard/'
if os.path.exists(keyboard_path):
for file in os.listdir(keyboard_path):
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)
# Ensure we have at least basic layouts
if not layouts:
layouts = ['desktop', 'laptop']
else:
layouts.sort()
return layouts
def run(self):
current_layout = self.env['runtime']['settingsManager'].getSetting('keyboard', 'keyboardLayout')
current_layout = self.env['runtime']['SettingsManager'].get_setting(
'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()
available_layouts = self.get_available_layouts()
# Find next layout in cycle
try:
current_index = available_layouts.index(current_layout)
@ -63,28 +72,29 @@ class command():
except ValueError:
# If current layout not found, start from beginning
next_index = 0
next_layout = available_layouts[next_index]
# Update setting and reload shortcuts
self.env['runtime']['settingsManager'].setSetting('keyboard', 'keyboardLayout', next_layout)
self.env['runtime']['SettingsManager'].set_setting(
'keyboard', 'keyboardLayout', next_layout)
# Reload shortcuts with new layout
try:
self.env['runtime']['inputManager'].reloadShortcuts()
self.env['runtime']['outputManager'].presentText(
_('Switched to {} keyboard layout').format(next_layout),
self.env['runtime']['InputManager'].reload_shortcuts()
self.env['runtime']['OutputManager'].present_text(
_('Switched to {} keyboard layout').format(next_layout),
interrupt=True
)
except Exception as e:
self.env['runtime']['debug'].writeDebugOut(
"Error reloading shortcuts: " + str(e),
debug.debugLevel.ERROR
self.env['runtime']['DebugManager'].write_debug_out(
"Error reloading shortcuts: " + str(e),
debug.DebugLevel.ERROR
)
self.env['runtime']['outputManager'].presentText(
_('Error switching keyboard layout'),
self.env['runtime']['OutputManager'].present_text(
_('Error switching keyboard layout'),
interrupt=True
)
def setCallback(self, callback):
pass
def set_callback(self, callback):
pass

28
src/fenrirscreenreader/commands/commands/date.py
View File

@ -4,26 +4,36 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
return _('presents the date')
def run(self):
dateFormat = self.env['runtime']['settingsManager'].getSetting('general', 'dateFormat')
date_format = self.env['runtime']['SettingsManager'].get_setting(
'general', 'date_format')
# get the time formatted
dateString = datetime.datetime.strftime(datetime.datetime.now(), dateFormat)
date_string = datetime.datetime.strftime(
datetime.datetime.now(), date_format)
# 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'].present_text(
date_string, sound_icon ='', interrupt=True)
def setCallback(self, callback):
def set_callback(self, callback):
pass

7
src/fenrirscreenreader/commands/commands/dec_alsa_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('alsa', 'volume', 'dec')

7
src/fenrirscreenreader/commands/commands/dec_sound_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('sound', 'volume', 'dec')

7
src/fenrirscreenreader/commands/commands/dec_speech_pitch.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'pitch', 'dec')

7
src/fenrirscreenreader/commands/commands/dec_speech_rate.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'rate', 'dec')

7
src/fenrirscreenreader/commands/commands/dec_speech_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'volume', 'dec')

34
src/fenrirscreenreader/commands/commands/exit_review.py
View File

@ -5,23 +5,31 @@
# By Chrys, Storm Dragon, and contributers.
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)
return
self.env['runtime']['cursorManager'].clearReviewCursor()
self.env['runtime']['outputManager'].presentText(_("Exiting Review Mode"), interrupt=True)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('exits review mode')
def run(self):
if not self.env['runtime']['CursorManager'].is_review_mode():
self.env['runtime']['OutputManager'].present_text(
_("Not in Review Mode"), interrupt=True)
return
self.env['runtime']['CursorManager'].clear_review_cursor()
self.env['runtime']['OutputManager'].present_text(
_("Exiting Review Mode"), interrupt=True)
def set_callback(self, callback):
pass

57
src/fenrirscreenreader/commands/commands/export_clipboard_to_file.py
View File

@ -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=''):
def initialize(self, environment, script_path=''):
self.env = environment
def shutdown(self):
pass
def getDescription(self):
def get_description(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')
def run(self):
clipboard_file_path = self.env['runtime']['SettingsManager'].get_setting(
'general', 'clipboardExportPath')
clipboard_file_path = clipboard_file_path.replace(
'$user', self.env['general']['curr_user'])
clipboard_file_path = clipboard_file_path.replace(
'$USER', self.env['general']['curr_user'])
clipboard_file_path = clipboard_file_path.replace(
'$User', self.env['general']['curr_user'])
clipboard_file = open(clipboard_file_path, 'w')
try:
if self.env['runtime']['memoryManager'].isIndexListEmpty('clipboardHistory'):
self.env['runtime']['outputManager'].presentText(_('clipboard empty'), interrupt=True)
return
clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
clipboardFile.write(clipboard)
clipboardFile.close()
os.chmod(clipboardFilePath, 0o644)
self.env['runtime']['outputManager'].presentText(_('clipboard exported to file'), interrupt=True)
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
clipboard_file.write(clipboard)
clipboard_file.close()
os.chmod(clipboard_file_path, 0o644)
self.env['runtime']['OutputManager'].present_text(
_('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)
def setCallback(self, callback):
self.env['runtime']['DebugManager'].write_debug_out(
'export_clipboard_to_file:run: Filepath:' +
clipboard_file +
' trace:' +
str(e),
debug.DebugLevel.ERROR)
def set_callback(self, callback):
pass

66
src/fenrirscreenreader/commands/commands/export_clipboard_to_x.py
View File

@ -4,37 +4,48 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
import os
import importlib
import _thread
import pyperclip
class command():
def __init__(self):
pass
def initialize(self, environment, scriptPath=''):
def initialize(self, environment, script_path=''):
self.env = environment
self.scriptPath = scriptPath
self.script_path = script_path
def shutdown(self):
pass
def getDescription(self):
def get_description(self):
return _('Export current fenrir clipboard to X or GUI clipboard')
def run(self):
_thread.start_new_thread(self._threadRun , ())
def _threadRun(self):
def run(self):
_thread.start_new_thread(self._thread_run, ())
def _thread_run(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'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
# Get current clipboard content
clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
# Remember original display environment variable if it exists
originalDisplay = os.environ.get('DISPLAY', '')
original_display = os.environ.get('DISPLAY', '')
success = False
# Try different display options
for i in range(10):
display = f":{i}"
@ -42,29 +53,34 @@ 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:
# Failed for this display, try next one
continue
# Restore original display setting
if originalDisplay:
os.environ['DISPLAY'] = originalDisplay
if original_display:
os.environ['DISPLAY'] = original_display
else:
os.environ.pop('DISPLAY', None)
# Notify the user of the result
if success:
self.env['runtime']['outputManager'].presentText(_('exported to the X session.'), interrupt=True)
self.env['runtime']['OutputManager'].present_text(
_('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'].present_text(
_('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)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
str(e), sound_icon ='', interrupt=False)
def set_callback(self, callback):
pass

36
src/fenrirscreenreader/commands/commands/first_clipboard.py
View File

@ -5,23 +5,33 @@
# By Chrys, Storm Dragon, and contributers.
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)
return
self.env['runtime']['memoryManager'].setFirstIndex('clipboardHistory')
clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
def setCallback(self, callback):
pass
def get_description(self):
return _('selects the first clipboard')
def run(self):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
self.env['runtime']['MemoryManager'].set_first_index('clipboardHistory')
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
self.env['runtime']['OutputManager'].present_text(
clipboard, interrupt=True)
def set_callback(self, callback):
pass

19
src/fenrirscreenreader/commands/commands/forward_keypress.py
View File

@ -5,19 +5,26 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(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'].present_text(
_('Forward next keypress'), interrupt=True)
def setCallback(self, callback):
def set_callback(self, callback):
pass

57
src/fenrirscreenreader/commands/commands/import_clipboard_from_file.py
View File

@ -4,35 +4,48 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if not os.path.exists(clipboardFilePath):
self.env['runtime']['outputManager'].presentText(_('File does not exist'), soundIcon='', interrupt=True)
return
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)
def setCallback(self, callback):
pass
def get_description(self):
return _('imports text from clipboard file to the clipboard')
def run(self):
clipboard_file_path = self.env['runtime']['SettingsManager'].get_setting(
'general', 'clipboardExportPath')
clipboard_file_path = clipboard_file_path.replace(
'$user', self.env['general']['curr_user'])
clipboard_file_path = clipboard_file_path.replace(
'$USER', self.env['general']['curr_user'])
clipboard_file_path = clipboard_file_path.replace(
'$User', self.env['general']['curr_user'])
if not os.path.exists(clipboard_file_path):
self.env['runtime']['OutputManager'].present_text(
_('File does not exist'), sound_icon ='', interrupt=True)
return
clipboard_file = open(clipboard_file_path, 'r')
imported = clipboard_file.read()
clipboard_file.close()
self.env['runtime']['MemoryManager'].add_value_to_first_index(
'clipboardHistory', imported)
self.env['runtime']['OutputManager'].present_text(
'Import to Clipboard', sound_icon ='CopyToClipboard', interrupt=True)
self.env['runtime']['OutputManager'].present_text(
imported, sound_icon ='', interrupt=False)
def set_callback(self, callback):
pass

65
src/fenrirscreenreader/commands/commands/import_clipboard_from_x.py
View File

@ -4,29 +4,37 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
import importlib
import _thread
import pyperclip
import os
class command():
def __init__(self):
pass
def initialize(self, environment, scriptPath=''):
def initialize(self, environment, script_path=''):
self.env = environment
self.scriptPath = scriptPath
self.script_path = script_path
def shutdown(self):
pass
def getDescription(self):
def get_description(self):
return _("imports the graphical clipboard to Fenrir's clipboard")
def run(self):
_thread.start_new_thread(self._threadRun , ())
def _threadRun(self):
def run(self):
_thread.start_new_thread(self._thread_run, ())
def _thread_run(self):
try:
# Remember original display environment variable if it exists
originalDisplay = os.environ.get('DISPLAY', '')
clipboardContent = None
original_display = os.environ.get('DISPLAY', '')
clipboard_content = None
# Try different display options
for i in range(10):
display = f":{i}"
@ -34,30 +42,37 @@ class command():
# Set display environment variable
os.environ['DISPLAY'] = display
# Attempt to get clipboard content
importlib.reload(pyperclip) # Weird workaround for some distros
clipboardContent = pyperclip.paste()
# If we get here without exception, we found a working display
if clipboardContent:
# Weird workaround for some distros
importlib.reload(pyperclip)
clipboard_content = pyperclip.paste()
# If we get here without exception, we found a working
# display
if clipboard_content:
break
except Exception:
# Failed for this display, try next one
continue
# Restore original display setting
if originalDisplay:
os.environ['DISPLAY'] = originalDisplay
if original_display:
os.environ['DISPLAY'] = original_display
else:
os.environ.pop('DISPLAY', None)
# 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)
if clipboard_content and isinstance(clipboard_content, str):
self.env['runtime']['MemoryManager'].add_value_to_first_index(
'clipboardHistory', clipboard_content)
self.env['runtime']['OutputManager'].present_text(
'Import to Clipboard', sound_icon ='CopyToClipboard', interrupt=True)
self.env['runtime']['OutputManager'].present_text(
clipboard_content, sound_icon ='', interrupt=False)
else:
self.env['runtime']['outputManager'].presentText('No text found in clipboard or no accessible display', interrupt=True)
self.env['runtime']['OutputManager'].present_text(
'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)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
str(e), sound_icon ='', interrupt=False)
def set_callback(self, callback):
pass

7
src/fenrirscreenreader/commands/commands/inc_alsa_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('alsa', 'volume', 'inc')

7
src/fenrirscreenreader/commands/commands/inc_sound_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('sound', 'volume', 'inc')

7
src/fenrirscreenreader/commands/commands/inc_speech_pitch.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'pitch', 'inc')

7
src/fenrirscreenreader/commands/commands/inc_speech_rate.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'rate', 'inc')

7
src/fenrirscreenreader/commands/commands/inc_speech_volume.py
View File

@ -4,14 +4,17 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
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
adjustment_command = _module.adjustment_command
class command(AdjustmentCommand):
class command(adjustment_command):
def __init__(self):
super().__init__('speech', 'volume', 'inc')

34
src/fenrirscreenreader/commands/commands/indent_curr_line.py
View File

@ -4,32 +4,40 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
return _('Presents the indentation level for the current line')
def run(self):
# Prefer review cursor over text cursor
if self.env['screen']['newCursorReview']:
cursorPos = self.env['screen']['newCursorReview'].copy()
cursor_pos = 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'])
if currLine.isspace():
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)
cursor_pos = self.env['screen']['new_cursor'].copy()
x, y, curr_line = line_utils.get_current_line(
cursor_pos['x'], cursor_pos['y'], self.env['screen']['new_content_text'])
def setCallback(self, callback):
if curr_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(_("indent {0}").format(
len(curr_line) - len(curr_line.lstrip())), interrupt=True)
def set_callback(self, callback):
pass

36
src/fenrirscreenreader/commands/commands/last_clipboard.py
View File

@ -5,23 +5,33 @@
# By Chrys, Storm Dragon, and contributers.
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)
return
self.env['runtime']['memoryManager'].setLastIndex('clipboardHistory')
clipboard = self.env['runtime']['memoryManager'].getIndexListElement('clipboardHistory')
self.env['runtime']['outputManager'].presentText(clipboard, interrupt=True)
def setCallback(self, callback):
pass
def get_description(self):
return _('selects the last clipboard')
def run(self):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
self.env['runtime']['MemoryManager'].set_last_index('clipboardHistory')
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
self.env['runtime']['OutputManager'].present_text(
clipboard, interrupt=True)
def set_callback(self, callback):
pass

39
src/fenrirscreenreader/commands/commands/marked_text.py
View File

@ -4,34 +4,45 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(self):
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'].present_text(
_("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()
start_mark = self.env['commandBuffer']['Marks']['1'].copy()
end_mark = self.env['commandBuffer']['Marks']['2'].copy()
marked = mark_utils.getTextBetweenMarks(startMark, endMark, self.env['screen']['newContentText'])
marked = mark_utils.get_text_between_marks(
start_mark, end_mark, self.env['screen']['new_content_text'])
if marked.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(marked, interrupt=True)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
marked, interrupt=True)
def set_callback(self, callback):
pass

56
src/fenrirscreenreader/commands/commands/next_clipboard.py
View File

@ -5,31 +5,45 @@
# By Chrys, Storm Dragon, and contributers.
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)
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')
if isFirst:
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)
def setCallback(self, callback):
pass
def get_description(self):
return _('selects the next clipboard')
def run(self):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
self.env['runtime']['MemoryManager'].get_next_index('clipboardHistory')
is_first = self.env['runtime']['MemoryManager'].is_first_index(
'clipboardHistory')
is_last = self.env['runtime']['MemoryManager'].is_last_index(
'clipboardHistory')
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
if is_first:
self.env['runtime']['OutputManager'].present_text(
_('First clipboard '), interrupt=True)
if is_last:
self.env['runtime']['OutputManager'].present_text(
_('Last clipboard '), interrupt=True)
speech_interrupt = not (is_last or is_first)
self.env['runtime']['OutputManager'].present_text(
clipboard, interrupt=speech_interrupt)
def set_callback(self, callback):
pass

26
src/fenrirscreenreader/commands/commands/next_quick_menu_entry.py
View File

@ -5,24 +5,34 @@
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(self):
return _('get next quick menu entry')
def run(self):
menu = ''
value = ''
if self.env['runtime']['quickMenuManager'].nextEntry():
menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
if self.env['runtime']['QuickMenuManager'].next_entry():
menu = self.env['runtime']['QuickMenuManager'].get_current_entry()
if menu != '':
value = self.env['runtime']['quickMenuManager'].getCurrentValue()
self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(
menu + ' ' + value, interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
_('Quick menu not available'), interrupt=True)
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/next_quick_menu_value.py
View File

@ -5,18 +5,27 @@
# By Chrys, Storm Dragon, and contributers.
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)
def setCallback(self, callback):
pass
def get_description(self):
return _('get next quick menu value')
def run(self):
if self.env['runtime']['QuickMenuManager'].next_value():
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(
value, interrupt=True)
def set_callback(self, callback):
pass

40
src/fenrirscreenreader/commands/commands/paste_clipboard.py
View File

@ -4,26 +4,38 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'].add_index_list(
'clipboardHistory', self.env['runtime']['SettingsManager'].get_setting_as_int(
'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)
return
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):
pass
def get_description(self):
return _('pastes the text from the currently selected clipboard')
def run(self):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
self.env['runtime']['OutputManager'].present_text(
'paste clipboard', sound_icon ='PasteClipboardOnScreen', interrupt=True)
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
self.env['runtime']['ScreenManager'].inject_text_to_screen(clipboard)
def set_callback(self, callback):
pass

34
src/fenrirscreenreader/commands/commands/present_first_line.py
View File

@ -4,26 +4,34 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if firstLine.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(firstLine, interrupt=True)
def setCallback(self, callback):
pass
def get_description(self):
return _('present first line')
def run(self):
x, y, first_line = line_utils.get_current_line(
0, 0, self.env['screen']['new_content_text'])
if first_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
first_line, interrupt=True)
def set_callback(self, callback):
pass

34
src/fenrirscreenreader/commands/commands/present_last_line.py
View File

@ -4,26 +4,34 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if lastLine.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(lastLine, interrupt=True)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('current line')
def run(self):
x, y, last_line = line_utils.get_current_line(
0, self.env['screen']['lines'] - 1, self.env['screen']['new_content_text'])
if last_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True)
else:
self.env['runtime']['OutputManager'].present_text(
last_line, interrupt=True)
def set_callback(self, callback):
pass

50
src/fenrirscreenreader/commands/commands/prev_clipboard.py
View File

@ -5,30 +5,44 @@
# By Chrys, Storm Dragon, and contributers.
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')
pass
def get_description(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)
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')
if isFirst:
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)
def setCallback(self, callback):
if self.env['runtime']['MemoryManager'].is_index_list_empty(
'clipboardHistory'):
self.env['runtime']['OutputManager'].present_text(
_('clipboard empty'), interrupt=True)
return
self.env['runtime']['MemoryManager'].set_pref_index('clipboardHistory')
is_first = self.env['runtime']['MemoryManager'].is_first_index(
'clipboardHistory')
is_last = self.env['runtime']['MemoryManager'].is_last_index(
'clipboardHistory')
clipboard = self.env['runtime']['MemoryManager'].get_index_list_element(
'clipboardHistory')
if is_first:
self.env['runtime']['OutputManager'].present_text(
_('First clipboard '), interrupt=True)
if is_last:
self.env['runtime']['OutputManager'].present_text(
_('Last clipboard '), interrupt=True)
speech_interrupt = not (is_last or is_first)
self.env['runtime']['OutputManager'].present_text(
clipboard, interrupt=speech_interrupt)
def set_callback(self, callback):
pass

26
src/fenrirscreenreader/commands/commands/prev_quick_menu_entry.py
View File

@ -5,24 +5,34 @@
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(self):
return _('get previous quick menu entry')
def run(self):
menu = ''
value = ''
if self.env['runtime']['quickMenuManager'].prevEntry():
menu = self.env['runtime']['quickMenuManager'].getCurrentEntry()
if self.env['runtime']['QuickMenuManager'].prev_entry():
menu = self.env['runtime']['QuickMenuManager'].get_current_entry()
if menu != '':
value = self.env['runtime']['quickMenuManager'].getCurrentValue()
self.env['runtime']['outputManager'].presentText(menu + ' ' + value, interrupt=True)
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(
menu + ' ' + value, interrupt=True)
else:
self.env['runtime']['outputManager'].presentText(_('Quick menu not available'), interrupt=True)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
_('Quick menu not available'), interrupt=True)
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/prev_quick_menu_value.py
View File

@ -5,18 +5,27 @@
# By Chrys, Storm Dragon, and contributers.
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)
def setCallback(self, callback):
pass
def get_description(self):
return _('get previous quick menu value')
def run(self):
if self.env['runtime']['QuickMenuManager'].prev_value():
value = self.env['runtime']['QuickMenuManager'].get_current_value()
self.env['runtime']['OutputManager'].present_text(
value, interrupt=True)
def set_callback(self, callback):
pass

222
src/fenrirscreenreader/commands/commands/progress_bar_monitor.py
View File

@ -4,206 +4,232 @@
# 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
# Check if progress monitoring should be enabled by default from
# settings
try:
defaultEnabled = self.env['runtime']['settingsManager'].getSettingAsBool('sound', 'progressMonitoring')
default_enabled = self.env['runtime']['SettingsManager'].get_setting_as_bool(
'sound', 'progressMonitoring')
except Exception as e:
# If setting doesn't exist, default to False
defaultEnabled = False
self.env['commandBuffer']['progressMonitoring'] = defaultEnabled
default_enabled = False
self.env['commandBuffer']['progressMonitoring'] = default_enabled
self.env['commandBuffer']['lastProgressTime'] = 0
self.env['commandBuffer']['lastProgressValue'] = -1
def shutdown(self):
self.stopProgressMonitoring()
def getDescription(self):
self.stop_progress_monitoring()
def get_description(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)
self.stop_progress_monitoring()
self.env['runtime']['OutputManager'].present_text(
_("Progress monitoring disabled"), interrupt=True)
else:
self.startProgressMonitoring()
self.env['runtime']['outputManager'].presentText(_("Progress monitoring enabled"), interrupt=True)
def startProgressMonitoring(self):
self.start_progress_monitoring()
self.env['runtime']['OutputManager'].present_text(
_("Progress monitoring enabled"), interrupt=True)
def start_progress_monitoring(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):
def stop_progress_monitoring(self):
self.env['commandBuffer']['progressMonitoring'] = False
# Don't control speech - progress monitor is beep-only
def detectProgress(self, text):
def detect_progress(self, text):
if not self.env['commandBuffer']['progressMonitoring']:
return
# Skip progress detection if current screen looks like a prompt
if self.isCurrentLinePrompt():
if self.is_current_line_prompt():
return
currentTime = time.time()
current_time = time.time()
# Pattern 1: Percentage (50%, 25.5%, etc.)
percentMatch = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
if percentMatch:
percentage = float(percentMatch.group(1))
percent_match = re.search(r'(\d+(?:\.\d+)?)\s*%', text)
if percent_match:
percentage = float(percent_match.group(1))
if percentage != self.env['commandBuffer']['lastProgressValue']:
self.playProgressTone(percentage)
self.play_progress_tone(percentage)
self.env['commandBuffer']['lastProgressValue'] = percentage
self.env['commandBuffer']['lastProgressTime'] = currentTime
self.env['commandBuffer']['lastProgressTime'] = current_time
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))
fraction_match = re.search(r'(\d+)\s*(?:of|/)\s*(\d+)', text)
if fraction_match:
current = int(fraction_match.group(1))
total = int(fraction_match.group(2))
if total > 0:
percentage = (current / total) * 100
if percentage != self.env['commandBuffer']['lastProgressValue']:
self.playProgressTone(percentage)
self.play_progress_tone(percentage)
self.env['commandBuffer']['lastProgressValue'] = percentage
self.env['commandBuffer']['lastProgressTime'] = currentTime
self.env['commandBuffer']['lastProgressTime'] = current_time
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))
bar_match = re.search(r'\[([#=\-\*]+)([\s\.]*)\]', text)
if bar_match:
filled = len(bar_match.group(1))
unfilled = len(bar_match.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))):
# Require at least 2 progress chars total and unfilled portion must
# be spaces/dots
if total >= 2 and (
not bar_match.group(2) or re.match(
r'^[\s\.]*$',
bar_match.group(2))):
percentage = (filled / total) * 100
if percentage != self.env['commandBuffer']['lastProgressValue']:
self.playProgressTone(percentage)
self.play_progress_tone(percentage)
self.env['commandBuffer']['lastProgressValue'] = percentage
self.env['commandBuffer']['lastProgressTime'] = currentTime
self.env['commandBuffer']['lastProgressTime'] = current_time
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:
activity_pattern = re.search(
r'(loading|processing|working|installing|downloading|compiling|building).*\.{2,}',
text,
re.IGNORECASE)
if activity_pattern:
# 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):
if current_time - \
self.env['commandBuffer']['lastProgressTime'] >= 2.0:
self.play_activity_beep()
self.env['commandBuffer']['lastProgressTime'] = current_time
def play_progress_tone(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):
self.env['runtime']['OutputManager'].play_frequence(
frequency, 0.15, interrupt=False)
def play_activity_beep(self):
# Single tone for generic activity
self.env['runtime']['outputManager'].playFrequence(800, 0.1, interrupt=False)
def isCurrentLinePrompt(self):
self.env['runtime']['OutputManager'].play_frequence(
800, 0.1, interrupt=False)
def is_current_line_prompt(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']:
if not self.env['screen']['new_content_text']:
return False
lines = self.env['screen']['newContentText'].split('\n')
lines = self.env['screen']['new_content_text'].split('\n')
if not lines:
return False
# Check the last line (most common) and current cursor line for prompt patterns
linesToCheck = []
# Check the last line (most common) and current cursor line for
# prompt patterns
lines_to_check = []
# Add last line (most common for prompts)
if lines:
linesToCheck.append(lines[-1])
lines_to_check.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']])
if (self.env['screen']['new_cursor']['y'] < len(lines) and
self.env['screen']['new_cursor']['y'] != len(lines) - 1):
lines_to_check.append(
lines[self.env['screen']['new_cursor']['y']])
# Standalone prompt patterns (no commands mixed in)
standalonePromptPatterns = [
standalone_prompt_patterns = [
r'^\s*\$\s*$', # Just $ (with whitespace)
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
r'.*continue\?\s*\[[YyNn]/[YyNn]\].*$', # "continue? [Y/n]" 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:
for line in lines_to_check:
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,
has_prompt_marker = bool(
re.search(
r'.*@.*[\\\$#>]',
line) or re.search(
r'^\[.*\]\s*[\\\$#>]',
line))
if has_prompt_marker:
# 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('#'),
prompt_end = max(
line.rfind('$'),
line.rfind('#'),
line.rfind('>'),
line.rfind('\\')
)
if promptEnd >= 0 and promptEnd < len(line) - 5: # More than just whitespace after prompt
if prompt_end >= 0 and prompt_end < len(
line) - 5: # More than just whitespace after prompt
continue # This is a command line, not a standalone prompt
for pattern in standalonePromptPatterns:
for pattern in standalone_prompt_patterns:
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
def set_callback(self, callback):
pass

21
src/fenrirscreenreader/commands/commands/quit_fenrir.py
View File

@ -5,19 +5,24 @@
# By Chrys, Storm Dragon, and contributers.
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')
def run(self):
self.env['runtime']['eventManager'].stopMainEventLoop()
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('exits Fenrir')
def run(self):
self.env['runtime']['EventManager'].stop_main_event_loop()
def set_callback(self, callback):
pass

25
src/fenrirscreenreader/commands/commands/remove_marks.py
View File

@ -5,19 +5,26 @@
# By Chrys, Storm Dragon, and contributers.
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)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('Removes marks from selected text')
def run(self):
self.env['runtime']['CursorManager'].clear_marks()
self.env['runtime']['OutputManager'].present_text(
_('Remove marks'), interrupt=True)
def set_callback(self, callback):
pass

68
src/fenrirscreenreader/commands/commands/remove_word_from_spell_check.py
View File

@ -4,6 +4,8 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
from fenrirscreenreader.utils import word_utils
import string
initialized = False
@ -12,43 +14,61 @@ try:
initialized = True
except Exception as e:
pass
class command():
def __init__(self):
self.language = ''
self.spellChecker = None
def initialize(self, environment):
self.env = environment
self.updateSpellLanguage()
self.update_spell_language()
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')
def get_description(self):
return _('removes the current word from the exceptions dictionary')
def update_spell_language(self):
self.spellChecker = enchant.Dict(
self.env['runtime']['SettingsManager'].get_setting(
'general', 'spellCheckLanguage'))
self.language = self.env['runtime']['SettingsManager'].get_setting(
'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'].present_text(
_('pyenchant is not installed'), interrupt=True)
return
if self.env['runtime']['SettingsManager'].get_setting(
'general', 'spellCheckLanguage') != self.language:
try:
self.updateSpellLanguage()
self.update_spell_language()
except Exception as e:
return
return
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
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'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
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)
new_content = self.env['screen']['new_content_text'].split('\n')[
cursor_pos['y']]
x, y, curr_word, end_of_screen, line_break = word_utils.get_current_word(
cursor_pos['x'], 0, new_content)
curr_word = curr_word.strip(
string.whitespace +
r'!"#$%&()*+,-./:;<=Â?@[\\]^_{|}~')
if not curr_word.isspace():
if self.spellChecker.is_removed(curr_word):
self.env['runtime']['OutputManager'].present_text(
_('{0} is not in the dictionary').format(
curr_word,), sound_icon ='Cancel', interrupt=True)
else:
self.spellChecker.remove(currWord)
self.env['runtime']['outputManager'].presentText(_('{0} removed').format(currWord,), soundIcon='Accept', interrupt=True)
def setCallback(self, callback):
self.spellChecker.remove(curr_word)
self.env['runtime']['OutputManager'].present_text(
_('{0} removed').format(curr_word,), sound_icon ='Accept', interrupt=True)
def set_callback(self, callback):
pass

18
src/fenrirscreenreader/commands/commands/review_bottom.py
View File

@ -5,19 +5,27 @@
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(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'].present_text(
_("Bottom"), interrupt=True, flush=False)
def setCallback(self, callback):
def set_callback(self, callback):
pass

54
src/fenrirscreenreader/commands/commands/review_curr_char.py
View File

@ -4,32 +4,46 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
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'):
cursorPos = self.env['screen']['newCursorReview']
if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
return
self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('presents the current character.')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_char = char_utils.get_current_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
char_utils.present_char_for_review(
self.env,
curr_char,
interrupt=True,
announce_capital=True,
flush=False)
# is has attribute it enabled?
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'general', 'hasattributes'):
cursor_pos = self.env['screen']['newCursorReview']
if not self.env['runtime']['AttributeManager'].has_attributes(
cursor_pos):
return
self.env['runtime']['OutputManager'].present_text(
'has attribute', sound_icon ='HasAttributes', interrupt=False)
def set_callback(self, callback):
pass

42
src/fenrirscreenreader/commands/commands/review_curr_char_phonetic.py
View File

@ -4,29 +4,37 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if currChar.isspace():
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)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('set review and phonetically presents the current character')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_char = char_utils.get_current_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if curr_char.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
curr_char = char_utils.get_phonetic(curr_char)
self.env['runtime']['OutputManager'].present_text(
curr_char, interrupt=True, announce_capital=True, flush=False)
def set_callback(self, callback):
pass

38
src/fenrirscreenreader/commands/commands/review_curr_line.py
View File

@ -4,28 +4,36 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if currLine.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(currLine, interrupt=True, flush=False)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('current line')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_line = line_utils.get_current_line(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if curr_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True, flush=False)
else:
self.env['runtime']['OutputManager'].present_text(
curr_line, interrupt=True, flush=False)
def set_callback(self, callback):
pass

47
src/fenrirscreenreader/commands/commands/review_curr_word.py
View File

@ -4,33 +4,46 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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.')
pass
def get_description(self):
return _('current word.')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
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['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_word, end_of_screen, line_break = word_utils.get_current_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if curr_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
curr_word, interrupt=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

61
src/fenrirscreenreader/commands/commands/review_curr_word_phonetic.py
View File

@ -4,37 +4,50 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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'])
if currWord.isspace():
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)
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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
pass
def get_description(self):
return _('Phonetically spells the current word')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_word, end_of_screen, line_break = word_utils.get_current_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if curr_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
first_sequence = True
for c in curr_word:
curr_char = char_utils.get_phonetic(c)
self.env['runtime']['OutputManager'].present_text(
curr_char, interrupt=first_sequence, announce_capital=True, flush=False)
first_sequence = False
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

36
src/fenrirscreenreader/commands/commands/review_down.py
View File

@ -4,25 +4,39 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('Move review to the character below the current position')
pass
def get_description(self):
return _('Move review to the character below the current position')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], downChar, endOfScreen = \
char_utils.getDownChar(self.env['screen']['newCursorReview']['x'],self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
self.env['runtime']['outputManager'].presentText(downChar ,interrupt=True, ignorePunctuation=True, announceCapital=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')
def setCallback(self, callback):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], downChar, end_of_screen = char_utils.get_down_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
self.env['runtime']['OutputManager'].present_text(
downChar,
interrupt=True,
ignore_punctuation=True,
announce_capital=True,
flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
def set_callback(self, callback):
pass

40
src/fenrirscreenreader/commands/commands/review_line_begin.py
View File

@ -4,29 +4,43 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(self):
return _('set review cursor to begin of current line and display the content')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
self.env['runtime']['cursorManager'].setReviewCursorPosition(0 ,cursorPos['y'])
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)
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['runtime']['CursorManager'].set_review_cursor_position(
0, cursor_pos['y'])
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_char = char_utils.get_current_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if curr_char.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(currChar ,interrupt=True, ignorePunctuation=True, announceCapital=True, flush=False)
self.env['runtime']['outputManager'].presentText(_("beginning of line"), interrupt=False)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
curr_char,
interrupt=True,
ignore_punctuation=True,
announce_capital=True,
flush=False)
self.env['runtime']['OutputManager'].present_text(
_("beginning of line"), interrupt=False)
def set_callback(self, callback):
pass

37
src/fenrirscreenreader/commands/commands/review_line_end.py
View File

@ -4,26 +4,39 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('Move Review to the end of current line and display the content')
pass
def get_description(self):
return _('Move Review to the end of current line and display the content')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
self.env['runtime']['cursorManager'].setReviewCursorPosition(self.env['screen']['columns']-1 ,cursorPos['y'])
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)
self.env['runtime']['outputManager'].presentText(_("end of line"), interrupt=False)
def setCallback(self, callback):
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['runtime']['CursorManager'].set_review_cursor_position(
self.env['screen']['columns'] - 1, cursor_pos['y'])
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_char = char_utils.get_current_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
self.env['runtime']['OutputManager'].present_text(
curr_char,
interrupt=True,
ignore_punctuation=True,
announce_capital=True,
flush=False)
self.env['runtime']['OutputManager'].present_text(
_("end of line"), interrupt=False)
def set_callback(self, callback):
pass

44
src/fenrirscreenreader/commands/commands/review_line_first_char.py
View File

@ -4,32 +4,46 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
from fenrirscreenreader.core.i18n import _
from fenrirscreenreader.utils import line_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):
pass
def get_description(self):
return _('Move Review to the first character on the line')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
x, y, currLine = \
line_utils.getCurrentLine(cursorPos['x'], cursorPos['y'], self.env['screen']['newContentText'])
if currLine.isspace():
self.env['runtime']['outputManager'].presentText(_("line is empty"), interrupt=True)
return
self.env['runtime']['cursorManager'].setReviewCursorPosition((len(currLine) - len(currLine.lstrip())), cursorPos['y'])
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'])
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
x, y, curr_line = line_utils.get_current_line(
cursor_pos['x'], cursor_pos['y'], self.env['screen']['new_content_text'])
if curr_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("line is empty"), interrupt=True)
return
self.env['runtime']['CursorManager'].set_review_cursor_position(
(len(curr_line) - len(curr_line.lstrip())), cursor_pos['y'])
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], curr_char = char_utils.get_current_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
char_utils.presentCharForReview(self.env, currChar, interrupt=True, announceCapital=True, flush=False)
self.env['runtime']['outputManager'].presentText(_("first character in line indent {0}").format(str(len(currLine) - len(currLine.lstrip()))), interrupt=False)
def setCallback(self, callback):
char_utils.present_char_for_review(
self.env,
curr_char,
interrupt=True,
announce_capital=True,
flush=False)
self.env['runtime']['OutputManager'].present_text(_("first character in line indent {0}").format(
str(len(curr_line) - len(curr_line.lstrip()))), interrupt=False)
def set_callback(self, callback):
pass

33
src/fenrirscreenreader/commands/commands/review_line_last_char.py
View File

@ -4,26 +4,39 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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):
pass
def get_description(self):
return _('Move Review to the last character on the line')
def run(self):
cursorPos = self.env['runtime']['cursorManager'].getReviewOrTextCursor()
self.env['runtime']['cursorManager'].setReviewCursorPosition(self.env['screen']['columns']-1 ,cursorPos['y'])
cursor_pos = self.env['runtime']['CursorManager'].get_review_or_text_cursor()
self.env['runtime']['CursorManager'].set_review_cursor_position(
self.env['screen']['columns'] - 1, cursor_pos['y'])
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], lastChar = \
char_utils.getLastCharInLine(self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
char_utils.presentCharForReview(self.env, lastChar, interrupt=True, announceCapital=True, flush=False)
self.env['runtime']['outputManager'].presentText(_("last character in line"), interrupt=False)
def setCallback(self, callback):
char_utils.get_last_char_in_line(self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
char_utils.present_char_for_review(
self.env,
lastChar,
interrupt=True,
announce_capital=True,
flush=False)
self.env['runtime']['OutputManager'].present_text(
_("last character in line"), interrupt=False)
def set_callback(self, callback):
pass

67
src/fenrirscreenreader/commands/commands/review_next_char.py
View File

@ -4,36 +4,55 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('Moves review to the next character ')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextChar, endOfScreen, lineBreak = \
char_utils.getNextChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
char_utils.presentCharForReview(self.env, nextChar, interrupt=True, announceCapital=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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
# is has attribute it enabled?
if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
cursorPos = self.env['screen']['newCursorReview']
if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
return
self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('Moves review to the next character ')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], next_char, end_of_screen, line_break = char_utils.get_next_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
char_utils.present_char_for_review(
self.env,
next_char,
interrupt=True,
announce_capital=True,
flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
# is has attribute it enabled?
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'general', 'hasattributes'):
cursor_pos = self.env['screen']['newCursorReview']
if not self.env['runtime']['AttributeManager'].has_attributes(
cursor_pos):
return
self.env['runtime']['OutputManager'].present_text(
'has attribute', sound_icon ='HasAttributes', interrupt=False)
def set_callback(self, callback):
pass

50
src/fenrirscreenreader/commands/commands/review_next_char_phonetic.py
View File

@ -4,31 +4,43 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('phonetically presents the next character and set review to it')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextChar, endOfScreen, lineBreak = \
char_utils.getNextChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
nextChar = char_utils.getPhonetic(nextChar)
self.env['runtime']['outputManager'].presentText(nextChar ,interrupt=True, announceCapital=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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('phonetically presents the next character and set review to it')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], next_char, end_of_screen, line_break = char_utils.get_next_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
next_char = char_utils.get_phonetic(next_char)
self.env['runtime']['OutputManager'].present_text(
next_char, interrupt=True, announce_capital=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

39
src/fenrirscreenreader/commands/commands/review_next_line.py
View File

@ -4,32 +4,43 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('moves review to the next line ')
pass
def get_description(self):
return _('moves review to the next line ')
def run(self):
self.env['screen']['oldCursorReview'] = self.env['screen']['newCursorReview']
if not self.env['screen']['newCursorReview']:
self.env['screen']['newCursorReview'] = self.env['screen']['newCursor'].copy()
self.env['screen']['newCursorReview'] = self.env['screen']['new_cursor'].copy()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextLine, end_of_screen = line_utils.get_next_line(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextLine, endOfScreen = \
line_utils.getNextLine(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if nextLine.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(nextLine, 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')
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
nextLine, interrupt=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
def set_callback(self, callback):
pass

51
src/fenrirscreenreader/commands/commands/review_next_word.py
View File

@ -4,35 +4,48 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('moves review to the next word ')
pass
def get_description(self):
return _('moves review to the next word ')
def run(self):
self.env['screen']['oldCursorReview'] = self.env['screen']['newCursorReview']
if self.env['screen']['newCursorReview'] == None:
self.env['screen']['newCursorReview'] = self.env['screen']['newCursor'].copy()
if self.env['screen']['newCursorReview'] is None:
self.env['screen']['newCursorReview'] = self.env['screen']['new_cursor'].copy()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextWord, endOfScreen, lineBreak = \
word_utils.getNextWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if nextWord.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], next_word, end_of_screen, line_break = word_utils.get_next_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if next_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(nextWord, 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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
next_word, interrupt=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

61
src/fenrirscreenreader/commands/commands/review_next_word_phonetic.py
View File

@ -4,37 +4,50 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 next word and moves review to it')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], nextWord, endOfScreen, lineBreak = \
word_utils.getNextWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if nextWord.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
else:
firstSequence = True
for c in nextWord:
currChar = char_utils.getPhonetic(c)
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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
pass
def get_description(self):
return _('Phonetically spells the next word and moves review to it')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], next_word, end_of_screen, line_break = word_utils.get_next_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if next_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
first_sequence = True
for c in next_word:
curr_char = char_utils.get_phonetic(c)
self.env['runtime']['OutputManager'].present_text(
curr_char, interrupt=first_sequence, announce_capital=True, flush=False)
first_sequence = False
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

63
src/fenrirscreenreader/commands/commands/review_prev_char.py
View File

@ -4,39 +4,58 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('moves review to the previous character ')
pass
def get_description(self):
return _('moves review to the previous character ')
def run(self):
self.env['screen']['oldCursorReview'] = self.env['screen']['newCursorReview']
if not self.env['screen']['newCursorReview']:
self.env['screen']['newCursorReview'] = self.env['screen']['newCursor'].copy()
self.env['screen']['newCursorReview'] = self.env['screen']['new_cursor'].copy()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prevChar, endOfScreen, lineBreak = \
char_utils.getPrevChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
char_utils.presentCharForReview(self.env, prevChar, interrupt=True, announceCapital=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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
# is has attribute it enabled?
if self.env['runtime']['settingsManager'].getSettingAsBool('general', 'hasAttributes'):
cursorPos = self.env['screen']['newCursorReview']
if not self.env['runtime']['attributeManager'].hasAttributes(cursorPos):
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prev_char, end_of_screen, line_break = char_utils.get_prev_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
char_utils.present_char_for_review(
self.env,
prev_char,
interrupt=True,
announce_capital=True,
flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
# is has attribute it enabled?
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'general', 'hasattributes'):
cursor_pos = self.env['screen']['newCursorReview']
if not self.env['runtime']['AttributeManager'].has_attributes(
cursor_pos):
return
self.env['runtime']['outputManager'].presentText('has attribute', soundIcon='HasAttributes', interrupt=False)
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
'has attribute', sound_icon ='HasAttributes', interrupt=False)
def set_callback(self, callback):
pass

50
src/fenrirscreenreader/commands/commands/review_prev_char_phonetic.py
View File

@ -4,31 +4,43 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('phonetically presents the previous character and set review to it')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prevChar, endOfScreen, lineBreak = \
char_utils.getPrevChar(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
prevChar = char_utils.getPhonetic(prevChar)
self.env['runtime']['outputManager'].presentText(prevChar ,interrupt=True, announceCapital=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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
def shutdown(self):
pass
def get_description(self):
return _('phonetically presents the previous character and set review to it')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prev_char, end_of_screen, line_break = char_utils.get_prev_char(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
prev_char = char_utils.get_phonetic(prev_char)
self.env['runtime']['OutputManager'].present_text(
prev_char, interrupt=True, announce_capital=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

38
src/fenrirscreenreader/commands/commands/review_prev_line.py
View File

@ -4,31 +4,41 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('moves review to the previous line ')
pass
def get_description(self):
return _('moves review to the previous line ')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prevLine, endOfScreen = \
line_utils.getPrevLine(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if prevLine.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), soundIcon='EmptyLine', interrupt=True, flush=False)
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prev_line, end_of_screen = line_utils.get_prev_line(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if prev_line.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), sound_icon ='EmptyLine', interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(prevLine, 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')
self.env['runtime']['OutputManager'].present_text(
prev_line, interrupt=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
def setCallback(self, callback):
def set_callback(self, callback):
pass

47
src/fenrirscreenreader/commands/commands/review_prev_word.py
View File

@ -4,33 +4,46 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 _('moves review focus to the previous word ')
pass
def get_description(self):
return _('moves review focus to the previous word ')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prevWord, endOfScreen, lineBreak = \
word_utils.getPrevWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if prevWord.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prev_word, end_of_screen, line_break = word_utils.get_prev_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if prev_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
self.env['runtime']['outputManager'].presentText(prevWord, interrupt=True, flush=False)
if endOfScreen:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'endOfScreen'):
self.env['runtime']['outputManager'].presentText(_('end of screen'), interrupt=False, soundIcon='EndOfScreen')
if lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
self.env['runtime']['OutputManager'].present_text(
prev_word, interrupt=True, flush=False)
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=False, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

61
src/fenrirscreenreader/commands/commands/review_prev_word_phonetic.py
View File

@ -4,37 +4,50 @@
# Fenrir TTY screen reader
# By Chrys, Storm Dragon, and contributers.
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 previous word and moves review to it')
def run(self):
self.env['runtime']['cursorManager'].enterReviewModeCurrTextCursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prevWord, endOfScreen, lineBreak = \
word_utils.getPrevWord(self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['newContentText'])
if prevWord.isspace():
self.env['runtime']['outputManager'].presentText(_("blank"), interrupt=True, flush=False)
else:
firstSequence = True
for c in prevWord:
currChar = char_utils.getPhonetic(c)
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 lineBreak:
if self.env['runtime']['settingsManager'].getSettingAsBool('review', 'lineBreak'):
self.env['runtime']['outputManager'].presentText(_('line break'), interrupt=False, soundIcon='EndOfLine')
def setCallback(self, callback):
pass
def get_description(self):
return _('Phonetically spells the previous word and moves review to it')
def run(self):
self.env['runtime']['CursorManager'].enter_review_mode_curr_text_cursor()
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], prev_word, end_of_screen, line_break = word_utils.get_prev_word(
self.env['screen']['newCursorReview']['x'], self.env['screen']['newCursorReview']['y'], self.env['screen']['new_content_text'])
if prev_word.isspace():
self.env['runtime']['OutputManager'].present_text(
_("blank"), interrupt=True, flush=False)
else:
first_sequence = True
for c in prev_word:
curr_char = char_utils.get_phonetic(c)
self.env['runtime']['OutputManager'].present_text(
curr_char, interrupt=first_sequence, announce_capital=True, flush=False)
first_sequence = False
if end_of_screen:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'end_of_screen'):
self.env['runtime']['OutputManager'].present_text(
_('end of screen'), interrupt=True, sound_icon ='EndOfScreen')
if line_break:
if self.env['runtime']['SettingsManager'].get_setting_as_bool(
'review', 'line_break'):
self.env['runtime']['OutputManager'].present_text(
_('line break'), interrupt=False, sound_icon ='EndOfLine')
def set_callback(self, callback):
pass

Some files were not shown because too many files have changed in this diff Show More