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

Simplified the plugin code. Hopefully it at least somewhat works better now.

Browse Source
This commit is contained in:
Storm Dragon 2025-04-03 14:00:06 -04:00
parent 312476bbed
commit 6bbe6e47fc
4 changed files with 226 additions and 1630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cthulhu/cthulhuVersion.py
View File

@ -23,5 +23,5 @@
# Fork of Orca Screen Reader (GNOME) # Fork of Orca Screen Reader (GNOME)
# Original source: https://gitlab.gnome.org/GNOME/orca # Original source: https://gitlab.gnome.org/GNOME/orca
version = "2025.03.27" version = "2025.04.03"
codeName = "testing" codeName = "testing"

514
src/cthulhu/plugin.py
View File

@ -1,507 +1,83 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
#
# Copyright (c) 2024 Stormux # Copyright (c) 2024 Stormux
# Copyright (c) 2010-2012 The Orca Team
# Copyright (c) 2012 Igalia, S.L.
# Copyright (c) 2005-2010 Sun Microsystems Inc.
# #
# This library is free software; you can redistribute it and/or # This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public # modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either # License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version. # version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA 02110-1301 USA.
#
# Fork of Orca Screen Reader (GNOME)
# Original source: https://gitlab.gnome.org/GNOME/orca
"""Base class for Cthulhu plugins using pluggy.""" """Base class for Cthulhu plugins using pluggy."""
import os import os
import inspect
import logging import logging
# Import pluggy for hook specifications # Import pluggy for hook specifications
try: try:
import pluggy import pluggy
cthulhu_hookimpl = pluggy.HookimplMarker("cthulhu") cthulhu_hookimpl = pluggy.HookimplMarker("cthulhu")
PLUGGY_AVAILABLE = True
except ImportError: except ImportError:
# Fallback if pluggy is not available # Fallback if pluggy is not available
def cthulhu_hookimpl(func=None, **kwargs): def cthulhu_hookimpl(func=None, **kwargs):
"""Dummy decorator for systems without pluggy."""
if func is None: if func is None:
return lambda f: f return lambda f: f
return func return func
PLUGGY_AVAILABLE = False
logging.getLogger(__name__).info("Pluggy not available, plugins will be disabled")
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
class Plugin: class Plugin:
"""Base class for Cthulhu plugins.""" """Base class for Cthulhu plugins."""
def __init__(self, *args, **kwargs): def __init__(self):
"""Initialize the plugin with default attributes.""" """Initialize the plugin with default attributes."""
self.app = None self.app = None
self.pluginInfo = None self.plugin_info = None
self.moduleDir = '' self.module_name = ''
self.hidden = False
self.moduleName = ''
self.name = '' self.name = ''
self.version = '' self.version = ''
self.website = ''
self.authors = []
self.buildIn = False
self.description = '' self.description = ''
self.iconName = ''
self.copyright = '' def set_app(self, app):
self.dependencies = False """Set the application reference."""
self.helpUri = ''
self.dataDir = ''
self.translationContext = None
self.dynamicApiManager = None
self.signalManager = None
def setApp(self, app):
"""Set the application reference.
Args:
app: The Cthulhu application instance.
"""
self.app = app self.app = app
self.dynamicApiManager = app.getDynamicApiManager()
self.signalManager = app.getSignalManager()
def getApp(self): def set_plugin_info(self, plugin_info):
"""Get the application reference. """Set plugin information and extract relevant attributes."""
self.plugin_info = plugin_info
Returns: if plugin_info:
The Cthulhu application instance. self.module_name = getattr(plugin_info, 'module_name', '')
""" self.name = getattr(plugin_info, 'name', '')
return self.app self.version = getattr(plugin_info, 'version', '')
self.description = getattr(plugin_info, 'description', '')
def setPluginInfo(self, pluginInfo):
"""Set the plugin information. @cthulhu_hookimpl
def activate(self, plugin=None):
Args: """Activate the plugin. Override this in subclasses."""
pluginInfo: The plugin information object. if plugin is not None and plugin is not self:
"""
self.pluginInfo = pluginInfo
self.updatePluginInfoAttributes()
def getPluginInfo(self):
"""Get the plugin information.
Returns:
The plugin information object.
"""
return self.pluginInfo
def updatePluginInfoAttributes(self):
"""Update plugin attributes from the plugin information."""
self.moduleDir = ''
self.hidden = False
self.moduleName = ''
self.name = ''
self.version = ''
self.website = ''
self.authors = []
self.buildIn = False
self.description = ''
self.iconName = ''
self.copyright = ''
self.dependencies = False
self.helpUri = ''
self.dataDir = ''
pluginInfo = self.getPluginInfo()
if pluginInfo is None:
return return
logger.info(f"Activating plugin: {self.name}")
if hasattr(self.app, 'getPluginSystemManager'):
plugin_system = self.app.getPluginSystemManager()
self.moduleName = plugin_system.getPluginModuleName(pluginInfo)
self.name = plugin_system.getPluginName(pluginInfo)
self.version = plugin_system.getPluginVersion(pluginInfo)
self.moduleDir = plugin_system.getPluginModuleDir(pluginInfo)
self.buildIn = plugin_system.isPluginBuildIn(pluginInfo)
self.description = plugin_system.getPluginDescription(pluginInfo)
self.hidden = plugin_system.isPluginHidden(pluginInfo)
self.website = plugin_system.getPluginWebsite(pluginInfo)
self.authors = plugin_system.getPluginAuthors(pluginInfo)
self.iconName = plugin_system.getPluginIconName(pluginInfo)
self.copyright = plugin_system.getPluginCopyright(pluginInfo)
self.dependencies = plugin_system.getPluginDependencies(pluginInfo)
self.helpUri = plugin_system.getPlugingetHelpUri(pluginInfo)
self.dataDir = plugin_system.getPluginDataDir(pluginInfo)
else:
# Direct attribute access for pluggy-based plugins
self.moduleName = getattr(pluginInfo, 'module_name', '')
self.name = getattr(pluginInfo, 'name', '')
self.version = getattr(pluginInfo, 'version', '')
self.moduleDir = getattr(pluginInfo, 'module_dir', '')
self.buildIn = getattr(pluginInfo, 'builtin', False)
self.description = getattr(pluginInfo, 'description', '')
self.hidden = getattr(pluginInfo, 'hidden', False)
self.website = getattr(pluginInfo, 'website', '')
self.authors = getattr(pluginInfo, 'authors', [])
self.iconName = getattr(pluginInfo, 'icon_name', '')
self.copyright = getattr(pluginInfo, 'copyright', '')
self.dependencies = getattr(pluginInfo, 'dependencies', [])
self.helpUri = getattr(pluginInfo, 'help_uri', '')
self.dataDir = getattr(pluginInfo, 'data_dir', '')
self.updateTranslationContext()
def updateTranslationContext(self, domain=None, localeDir=None, language=None, fallbackToCthulhuTranslation=True):
"""Update the translation context.
Args:
domain: The translation domain.
localeDir: The locale directory.
language: The language to use.
fallbackToCthulhuTranslation: Whether to fall back to Cthulhu translations.
"""
self.translationContext = None
useLocaleDir = f'{self.getModuleDir()}/locale/'
if localeDir:
if os.path.isdir(localeDir):
useLocaleDir = localeDir
useName = self.getModuleName()
useDomain = useName
if domain:
useDomain = domain
useLanguage = None
if language:
useLanguage = language
translation_manager = self.getApp().getTranslationManager()
self.translationContext = translation_manager.initTranslation(
useName,
domain=useDomain,
localeDir=useLocaleDir,
language=useLanguage,
fallbackToCthulhuTranslation=fallbackToCthulhuTranslation
)
# Point _ to the translation object in the globals namespace of the caller frame
try:
callerFrame = inspect.currentframe().f_back
# Install our gettext and ngettext function to the upper frame
callerFrame.f_globals['_'] = self.translationContext.gettext
callerFrame.f_globals['ngettext'] = self.translationContext.ngettext
finally:
del callerFrame # Avoid reference problems with frames (per python docs)
def getTranslationContext(self):
"""Get the translation context.
Returns:
The translation context.
"""
return self.translationContext
def isPluginBuildIn(self):
"""Check if the plugin is built-in.
Returns:
True if the plugin is built-in, False otherwise.
"""
return self.buildIn
def isPluginHidden(self):
"""Check if the plugin is hidden.
Returns:
True if the plugin is hidden, False otherwise.
"""
return self.hidden
def getAuthors(self):
"""Get the plugin authors.
Returns:
A list of plugin authors.
"""
return self.authors
def getCopyright(self):
"""Get the plugin copyright.
Returns:
The plugin copyright.
"""
return self.copyright
def getDataDir(self):
"""Get the plugin data directory.
Returns:
The plugin data directory.
"""
return self.dataDir
def getDependencies(self):
"""Get the plugin dependencies.
Returns:
The plugin dependencies.
"""
return self.dependencies
def getDescription(self):
"""Get the plugin description.
Returns:
The plugin description.
"""
return self.description
def getgetHelpUri(self):
"""Get the plugin help URI.
Returns:
The plugin help URI.
"""
return self.helpUri
def getIconName(self):
"""Get the plugin icon name.
Returns:
The plugin icon name.
"""
return self.iconName
def getModuleDir(self):
"""Get the plugin module directory.
Returns:
The plugin module directory.
"""
return self.moduleDir
def getModuleName(self):
"""Get the plugin module name.
Returns:
The plugin module name.
"""
return self.moduleName
def getName(self):
"""Get the plugin name.
Returns:
The plugin name.
"""
return self.name
def getVersion(self):
"""Get the plugin version.
Returns:
The plugin version.
"""
return self.version
def getWebsite(self):
"""Get the plugin website.
Returns:
The plugin website.
"""
return self.website
def getSetting(self, key):
"""Get a plugin setting.
Args:
key: The setting key.
Returns:
The setting value, or None if not found.
"""
# To be implemented
return None
def setSetting(self, key, value):
"""Set a plugin setting.
Args:
key: The setting key.
value: The setting value.
"""
# To be implemented
pass
def registerGestureByString(self, function, name, gestureString, learnModeEnabled=True):
"""Register a gesture by string.
Args:
function: The function to call when the gesture is triggered.
name: The name of the gesture.
gestureString: The gesture string.
learnModeEnabled: Whether the gesture is enabled in learn mode.
Returns:
The registered keybinding.
"""
keybinding = self.getApp().getAPIHelper().registerGestureByString(
function,
name,
gestureString,
'default',
'cthulhu',
learnModeEnabled,
contextName=self.getModuleName()
)
return keybinding
def unregisterShortcut(self, keybinding, learnModeEnabled=True):
"""Unregister a shortcut.
Args:
keybinding: The keybinding to unregister.
learnModeEnabled: Whether the shortcut is enabled in learn mode.
Returns:
True if the shortcut was unregistered, False otherwise.
"""
ok = self.getApp().getAPIHelper().unregisterShortcut(
keybinding,
contextName=self.getModuleName()
)
return ok
def registerSignal(self, signalName, signalFlag=None, closure=None, accumulator=()):
"""Register a signal.
Args:
signalName: The signal name.
signalFlag: The signal flags.
closure: The closure.
accumulator: The accumulator.
Returns:
True if the signal was registered, False otherwise.
"""
if signalFlag is None:
# Import GObject if available, otherwise use a dummy value
try:
from gi.repository import GObject
signalFlag = GObject.SignalFlags.RUN_LAST
except ImportError:
signalFlag = 1 # Default value
if closure is None:
try:
from gi.repository import GObject
closure = GObject.TYPE_NONE
except ImportError:
closure = None # Default value
ok = self.signalManager.registerSignal(
signalName,
signalFlag,
closure,
accumulator,
contextName=self.getModuleName()
)
return ok
def unregisterSignal(self, signalName):
"""Unregister a signal.
Args:
signalName: The signal name.
"""
# To be implemented
pass
def connectSignal(self, signalName, function, param=None):
"""Connect to a signal.
Args:
signalName: The signal name.
function: The function to call when the signal is triggered.
param: The parameter to pass to the function.
Returns:
The signal ID.
"""
signalID = self.signalManager.connectSignal(
signalName,
function,
param,
contextName=self.getModuleName()
)
return signalID
def disconnectSignalByFunction(self, function):
"""Disconnect a signal by function.
Args:
function: The function to disconnect.
"""
# Need to get mapped function
mappedFunction = function
self.signalManager.disconnectSignalByFunction(
mappedFunction,
contextName=self.getModuleName()
)
def registerAPI(self, key, value, application=''):
"""Register an API.
Args:
key: The API key.
value: The API value.
application: The application.
Returns:
True if the API was registered, False otherwise.
"""
ok = self.dynamicApiManager.registerAPI(
key,
value,
application=application,
contextName=self.getModuleName()
)
return ok
def unregisterAPI(self, key, application=''):
"""Unregister an API.
Args:
key: The API key.
application: The application.
"""
self.dynamicApiManager.unregisterAPI(
key,
application=application,
contextName=self.getModuleName()
)
# Pluggy-specific hook implementations
@cthulhu_hookimpl @cthulhu_hookimpl
def activate(self): def deactivate(self, plugin=None):
"""Activate the plugin. This method should be overridden by subclasses.""" """Deactivate the plugin. Override this in subclasses."""
logger.info(f"Activating plugin: {self.getName()}") if plugin is not None and plugin is not self:
return
@cthulhu_hookimpl logger.info(f"Deactivating plugin: {self.name}")
def deactivate(self):
"""Deactivate the plugin. This method should be overridden by subclasses.""" def registerGestureByString(self, function, name, gestureString, learnModeEnabled=True):
logger.info(f"Deactivating plugin: {self.getName()}") """Register a gesture by string."""
if self.app:
api_helper = self.app.getAPIHelper()
if api_helper:
return api_helper.registerGestureByString(
function,
name,
gestureString,
'default',
'cthulhu',
learnModeEnabled,
contextName=self.module_name
)
return None

1279
src/cthulhu/plugin_system_manager.py
View File

File diff suppressed because it is too large Load Diff

61
src/cthulhu/plugins/hello_world/plugin.py
View File

@ -6,75 +6,64 @@
# modify it under the terms of the GNU Lesser General Public # modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either # License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version. # version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA 02110-1301 USA.
"""Hello World plugin for Cthulhu using pluggy.""" """Hello World plugin for Cthulhu."""
import os
import logging import logging
# Import from cthulhu
from cthulhu.plugin import Plugin, cthulhu_hookimpl from cthulhu.plugin import Plugin, cthulhu_hookimpl
logger = logging.getLogger(__name__) logger = logging.getLogger(__name__)
class HelloWorld(Plugin): class HelloWorld(Plugin):
"""Hello World plugin for Cthulhu.""" """Hello World plugin."""
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
"""Initialize the plugin.""" """Initialize the plugin."""
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
print("HelloWorld plugin initialized") logger.info("HelloWorld plugin initialized")
@cthulhu_hookimpl @cthulhu_hookimpl
def activate(self): def activate(self, plugin=None):
"""Activate the plugin.""" """Activate the plugin."""
# Skip if this activation call isn't for us
if plugin is not None and plugin is not self:
return
try: try:
print("Activate Hello World plugin") logger.info("Activating Hello World plugin")
# Register our keyboard shortcut, same as the original (cthulhu+z) # Register our keyboard shortcut
self.registerGestureByString( self.registerGestureByString(
self.speakTest, self.speakTest,
"hello world", "hello world",
"kb:cthulhu+z", "kb:cthulhu+z",
learnModeEnabled=True learnModeEnabled=True
) )
return True
except Exception as e: except Exception as e:
print(f"Error activating Hello World plugin: {e}") logger.error(f"Error activating Hello World plugin: {e}")
return False
@cthulhu_hookimpl @cthulhu_hookimpl
def deactivate(self): def deactivate(self, plugin=None):
"""Deactivate the plugin.""" """Deactivate the plugin."""
# Skip if this deactivation call isn't for us
if plugin is not None and plugin is not self:
return
try: try:
print("Deactivate Hello World plugin") logger.info("Deactivating Hello World plugin")
return True
except Exception as e: except Exception as e:
print(f"Error deactivating Hello World plugin: {e}") logger.error(f"Error deactivating Hello World plugin: {e}")
return False
def speakTest(self, script=None, inputEvent=None): def speakTest(self, script=None, inputEvent=None):
"""Speak a test message.""" """Speak a test message."""
try: try:
if self.app: if self.app:
# Use the same API call as in the original plugin
self.app.getDynamicApiManager().getAPI('CthulhuState').activeScript.presentMessage( self.app.getDynamicApiManager().getAPI('CthulhuState').activeScript.presentMessage(
'hello world', 'hello world',
resetStyles=False resetStyles=False
) )
return True return True
except Exception as e: except Exception as e:
print(f"Error in speakTest: {e}") logger.error(f"Error in speakTest: {e}")
return False return False