mirror of
https://github.com/EDCD/EDMarketConnector.git
synced 2025-04-14 00:07:14 +03:00
558392d21b
Where it was in EDMarketConnector.py caused issues because then the
main thread was blocking on the popup when other threads expected it to
be running:
---------------------------------------------------------------------
Exception in thread Journal worker:
Traceback (most recent call last):
File "C:\Users\Athan\AppData\Local\Programs\Python\Python37-32\lib\threading.py", line 926, in _bootstrap_inner
self.run()
File "C:\Users\Athan\AppData\Local\Programs\Python\Python37-32\lib\threading.py", line 870, in run
self._target(*self._args, **self._kwargs)
File "C:\Users\Athan\Documents\Devel\EDMarketConnector-python3\monitor.py", line 273, in worker
self.root.event_generate('<<JournalEvent>>', when="tail")
File "C:\Users\Athan\AppData\Local\Programs\Python\Python37-32\lib\tkinter\__init__.py", line 1673, in event_generate
self.tk.call(args)
RuntimeError: main thread is not in main loop
---------------------------------------------------------------------
However *now* it pops up before the main UI is running properly at all,
so the EDMC window is likely out of position, and won't be
painted/themed yet.
This is deemed acceptable for a 'once a day at most' popup.
The popup title now has 'EDMC: ' at the start to be sure users know
what it's talking about.
It also has some brief advice about how to disable a plugin.
362 lines
13 KiB
Python
362 lines
13 KiB
Python
"""
|
|
Plugin hooks for EDMC - Ian Norton, Jonathan Harris
|
|
"""
|
|
from builtins import str
|
|
from builtins import object
|
|
import os
|
|
import importlib
|
|
import sys
|
|
import operator
|
|
import threading # We don't use it, but plugins might
|
|
from traceback import print_exc
|
|
|
|
import tkinter as tk
|
|
import myNotebook as nb
|
|
|
|
from config import config
|
|
from time import time as time
|
|
|
|
|
|
# Dashboard Flags constants
|
|
FlagsDocked = 1<<0 # on a landing pad
|
|
FlagsLanded = 1<<1 # on planet surface
|
|
FlagsLandingGearDown = 1<<2
|
|
FlagsShieldsUp = 1<<3
|
|
FlagsSupercruise = 1<<4
|
|
FlagsFlightAssistOff = 1<<5
|
|
FlagsHardpointsDeployed = 1<<6
|
|
FlagsInWing = 1<<7
|
|
FlagsLightsOn = 1<<8
|
|
FlagsCargoScoopDeployed = 1<<9
|
|
FlagsSilentRunning = 1<<10
|
|
FlagsScoopingFuel = 1<<11
|
|
FlagsSrvHandbrake = 1<<12
|
|
FlagsSrvTurret = 1<<13 # using turret view
|
|
FlagsSrvUnderShip = 1<<14 # turret retracted
|
|
FlagsSrvDriveAssist = 1<<15
|
|
FlagsFsdMassLocked = 1<<16
|
|
FlagsFsdCharging = 1<<17
|
|
FlagsFsdCooldown = 1<<18
|
|
FlagsLowFuel = 1<<19 # <25%
|
|
FlagsOverHeating = 1<<20 # > 100%
|
|
FlagsHasLatLong = 1<<21
|
|
FlagsIsInDanger = 1<<22
|
|
FlagsBeingInterdicted = 1<<23
|
|
FlagsInMainShip = 1<<24
|
|
FlagsInFighter = 1<<25
|
|
FlagsInSRV = 1<<26
|
|
FlagsAnalysisMode = 1<<27 # Hud in Analysis mode
|
|
FlagsNightVision = 1<<28
|
|
FlagsAverageAltitude = 1<<29 # Altitude from Average radius
|
|
FlagsFsdJump = 1<<30
|
|
FlagsSrvHighBeam = 1<<31
|
|
|
|
# Dashboard GuiFocus constants
|
|
GuiFocusNoFocus = 0
|
|
GuiFocusInternalPanel = 1 # right hand side
|
|
GuiFocusExternalPanel = 2 # left hand side
|
|
GuiFocusCommsPanel = 3 # top
|
|
GuiFocusRolePanel = 4 # bottom
|
|
GuiFocusStationServices = 5
|
|
GuiFocusGalaxyMap = 6
|
|
GuiFocusSystemMap = 7
|
|
GuiFocusOrrery = 8
|
|
GuiFocusFSS = 9
|
|
GuiFocusSAA = 10
|
|
GuiFocusCodex = 11
|
|
|
|
|
|
# List of loaded Plugins
|
|
PLUGINS = []
|
|
PLUGINS_not_py3 = []
|
|
|
|
# For asynchronous error display
|
|
last_error = {
|
|
'msg': None,
|
|
'root': None,
|
|
}
|
|
|
|
|
|
class Plugin(object):
|
|
|
|
def __init__(self, name, loadfile):
|
|
"""
|
|
Load a single plugin
|
|
:param name: module name
|
|
:param loadfile: the main .py file
|
|
:raises Exception: Typically ImportError or OSError
|
|
"""
|
|
|
|
self.name = name # Display name.
|
|
self.folder = name # basename of plugin folder. None for internal plugins.
|
|
self.module = None # None for disabled plugins.
|
|
|
|
if loadfile:
|
|
sys.stdout.write('loading plugin {} from "{}"\n'.format(name.replace('.', '_'), loadfile))
|
|
try:
|
|
module = importlib.machinery.SourceFileLoader('plugin_{}'.format(name.encode(encoding='ascii', errors='replace').decode('utf-8').replace('.', '_')), loadfile).load_module()
|
|
if getattr(module, 'plugin_start3', None):
|
|
newname = module.plugin_start3(os.path.dirname(loadfile))
|
|
self.name = newname and str(newname) or name
|
|
self.module = module
|
|
elif getattr(module, 'plugin_start', None):
|
|
sys.stdout.write('plugin %s needs migrating\n' % name)
|
|
PLUGINS_not_py3.append(self)
|
|
else:
|
|
sys.stdout.write('plugin %s has no plugin_start3() function\n' % name)
|
|
except:
|
|
print_exc()
|
|
raise
|
|
else:
|
|
sys.stdout.write('plugin %s disabled\n' % name)
|
|
|
|
def _get_func(self, funcname):
|
|
"""
|
|
Get a function from a plugin
|
|
:param funcname:
|
|
:returns: The function, or None if it isn't implemented.
|
|
"""
|
|
return getattr(self.module, funcname, None)
|
|
|
|
def get_app(self, parent):
|
|
"""
|
|
If the plugin provides mainwindow content create and return it.
|
|
:param parent: the parent frame for this entry.
|
|
:returns: None, a tk Widget, or a pair of tk.Widgets
|
|
"""
|
|
plugin_app = self._get_func('plugin_app')
|
|
if plugin_app:
|
|
try:
|
|
appitem = plugin_app(parent)
|
|
if appitem is None:
|
|
return None
|
|
elif isinstance(appitem, tuple):
|
|
if len(appitem) != 2 or not isinstance(appitem[0], tk.Widget) or not isinstance(appitem[1], tk.Widget):
|
|
raise AssertionError
|
|
elif not isinstance(appitem, tk.Widget):
|
|
raise AssertionError
|
|
return appitem
|
|
except:
|
|
print_exc()
|
|
return None
|
|
|
|
def get_prefs(self, parent, cmdr, is_beta):
|
|
"""
|
|
If the plugin provides a prefs frame, create and return it.
|
|
:param parent: the parent frame for this preference tab.
|
|
:param cmdr: current Cmdr name (or None). Relevant if you want to have
|
|
different settings for different user accounts.
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
:returns: a myNotebook Frame
|
|
"""
|
|
plugin_prefs = self._get_func('plugin_prefs')
|
|
if plugin_prefs:
|
|
try:
|
|
frame = plugin_prefs(parent, cmdr, is_beta)
|
|
if not isinstance(frame, nb.Frame):
|
|
raise AssertionError
|
|
return frame
|
|
except:
|
|
print_exc()
|
|
return None
|
|
|
|
|
|
def load_plugins(master):
|
|
"""
|
|
Find and load all plugins
|
|
"""
|
|
last_error['root'] = master
|
|
|
|
internal = []
|
|
for name in os.listdir(config.internal_plugin_dir):
|
|
if name.endswith('.py') and not name[0] in ['.', '_']:
|
|
try:
|
|
plugin = Plugin(name[:-3], os.path.join(config.internal_plugin_dir, name))
|
|
plugin.folder = None # Suppress listing in Plugins prefs tab
|
|
internal.append(plugin)
|
|
except:
|
|
pass
|
|
PLUGINS.extend(sorted(internal, key = lambda p: operator.attrgetter('name')(p).lower()))
|
|
|
|
# Add plugin folder to load path so packages can be loaded from plugin folder
|
|
sys.path.append(config.plugin_dir)
|
|
|
|
found = []
|
|
# Load any plugins that are also packages first
|
|
for name in sorted(os.listdir(config.plugin_dir),
|
|
key = lambda n: (not os.path.isfile(os.path.join(config.plugin_dir, n, '__init__.py')), n.lower())):
|
|
if not os.path.isdir(os.path.join(config.plugin_dir, name)) or name[0] in ['.', '_']:
|
|
pass
|
|
elif name.endswith('.disabled'):
|
|
name, discard = name.rsplit('.', 1)
|
|
found.append(Plugin(name, None))
|
|
else:
|
|
try:
|
|
# Add plugin's folder to load path in case plugin has internal package dependencies
|
|
sys.path.append(os.path.join(config.plugin_dir, name))
|
|
found.append(Plugin(name, os.path.join(config.plugin_dir, name, 'load.py')))
|
|
except:
|
|
pass
|
|
PLUGINS.extend(sorted(found, key = lambda p: operator.attrgetter('name')(p).lower()))
|
|
|
|
plugins_not_py3_last = config.getint('plugins_not_py3_last') or 0
|
|
if (plugins_not_py3_last + 86400) < int(time()) and len(PLUGINS_not_py3):
|
|
tk.messagebox.showinfo('EDMC: Plugins Without Python 3.x Support',
|
|
"One or more of your enabled plugins do not yet have support for Python 3.x. Please see the list on the 'Plugins' tab of 'File' > 'Settings'. You should check if there is an updated version available, else alert the developer that they need to update the code for Python 3.x\r\n\r\nYou can disable a plugin by renaming its folder to have '.disabled' on the end of the name."
|
|
)
|
|
config.set('plugins_not_py3_last', int(time()))
|
|
|
|
def provides(fn_name):
|
|
"""
|
|
Find plugins that provide a function
|
|
:param fn_name:
|
|
:returns: list of names of plugins that provide this function
|
|
.. versionadded:: 3.0.2
|
|
"""
|
|
return [p.name for p in PLUGINS if p._get_func(fn_name)]
|
|
|
|
def invoke(plugin_name, fallback, fn_name, *args):
|
|
"""
|
|
Invoke a function on a named plugin
|
|
:param plugin_name: preferred plugin on which to invoke the function
|
|
:param fallback: fallback plugin on which to invoke the function, or None
|
|
:param fn_name:
|
|
:param *args: arguments passed to the function
|
|
:returns: return value from the function, or None if the function was not found
|
|
.. versionadded:: 3.0.2
|
|
"""
|
|
for plugin in PLUGINS:
|
|
if plugin.name == plugin_name and plugin._get_func(fn_name):
|
|
return plugin._get_func(fn_name)(*args)
|
|
for plugin in PLUGINS:
|
|
if plugin.name == fallback:
|
|
assert plugin._get_func(fn_name), plugin.name # fallback plugin should provide the function
|
|
return plugin._get_func(fn_name)(*args)
|
|
|
|
|
|
def notify_stop():
|
|
"""
|
|
Notify each plugin that the program is closing.
|
|
If your plugin uses threads then stop and join() them before returning.
|
|
.. versionadded:: 2.3.7
|
|
"""
|
|
error = None
|
|
for plugin in PLUGINS:
|
|
plugin_stop = plugin._get_func('plugin_stop')
|
|
if plugin_stop:
|
|
try:
|
|
newerror = plugin_stop()
|
|
error = error or newerror
|
|
except:
|
|
print_exc()
|
|
return error
|
|
|
|
|
|
def notify_prefs_cmdr_changed(cmdr, is_beta):
|
|
"""
|
|
Notify each plugin that the Cmdr has been changed while the settings dialog is open.
|
|
Relevant if you want to have different settings for different user accounts.
|
|
:param cmdr: current Cmdr name (or None).
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
"""
|
|
for plugin in PLUGINS:
|
|
prefs_cmdr_changed = plugin._get_func('prefs_cmdr_changed')
|
|
if prefs_cmdr_changed:
|
|
try:
|
|
prefs_cmdr_changed(cmdr, is_beta)
|
|
except:
|
|
print_exc()
|
|
|
|
|
|
def notify_prefs_changed(cmdr, is_beta):
|
|
"""
|
|
Notify each plugin that the settings dialog has been closed.
|
|
The prefs frame and any widgets you created in your `get_prefs()` callback
|
|
will be destroyed on return from this function, so take a copy of any
|
|
values that you want to save.
|
|
:param cmdr: current Cmdr name (or None).
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
"""
|
|
for plugin in PLUGINS:
|
|
prefs_changed = plugin._get_func('prefs_changed')
|
|
if prefs_changed:
|
|
try:
|
|
prefs_changed(cmdr, is_beta)
|
|
except:
|
|
print_exc()
|
|
|
|
|
|
def notify_journal_entry(cmdr, is_beta, system, station, entry, state):
|
|
"""
|
|
Send a journal entry to each plugin.
|
|
:param cmdr: The Cmdr name, or None if not yet known
|
|
:param system: The current system, or None if not yet known
|
|
:param station: The current station, or None if not docked or not yet known
|
|
:param entry: The journal entry as a dictionary
|
|
:param state: A dictionary containing info about the Cmdr, current ship and cargo
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
:returns: Error message from the first plugin that returns one (if any)
|
|
"""
|
|
error = None
|
|
for plugin in PLUGINS:
|
|
journal_entry = plugin._get_func('journal_entry')
|
|
if journal_entry:
|
|
try:
|
|
# Pass a copy of the journal entry in case the callee modifies it
|
|
newerror = journal_entry(cmdr, is_beta, system, station, dict(entry), dict(state))
|
|
error = error or newerror
|
|
except:
|
|
print_exc()
|
|
return error
|
|
|
|
|
|
def notify_dashboard_entry(cmdr, is_beta, entry):
|
|
"""
|
|
Send a status entry to each plugin.
|
|
:param cmdr: The piloting Cmdr name
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
:param entry: The status entry as a dictionary
|
|
:returns: Error message from the first plugin that returns one (if any)
|
|
"""
|
|
error = None
|
|
for plugin in PLUGINS:
|
|
status = plugin._get_func('dashboard_entry')
|
|
if status:
|
|
try:
|
|
# Pass a copy of the status entry in case the callee modifies it
|
|
newerror = status(cmdr, is_beta, dict(entry))
|
|
error = error or newerror
|
|
except:
|
|
print_exc()
|
|
return error
|
|
|
|
|
|
def notify_newdata(data, is_beta):
|
|
"""
|
|
Send the latest EDMC data from the FD servers to each plugin
|
|
:param data:
|
|
:param is_beta: whether the player is in a Beta universe.
|
|
:returns: Error message from the first plugin that returns one (if any)
|
|
"""
|
|
error = None
|
|
for plugin in PLUGINS:
|
|
cmdr_data = plugin._get_func('cmdr_data')
|
|
if cmdr_data:
|
|
try:
|
|
newerror = cmdr_data(data, is_beta)
|
|
error = error or newerror
|
|
except:
|
|
print_exc()
|
|
return error
|
|
|
|
|
|
def show_error(err):
|
|
"""
|
|
Display an error message in the status line of the main window.
|
|
:param err:
|
|
.. versionadded:: 2.3.7
|
|
"""
|
|
if err and last_error['root']:
|
|
last_error['msg'] = str(err)
|
|
last_error['root'].event_generate('<<PluginError>>', when="tail")
|