mirror of
https://github.com/EDCD/EDMarketConnector.git
synced 2026-10-25 01:06:05 +03:00
481 lines
22 KiB
Python
481 lines
22 KiB
Python
"""
|
|
theme.py - Theme support.
|
|
|
|
Copyright (c) EDCD, All Rights Reserved
|
|
Licensed under the GNU General Public License v2 or later.
|
|
See LICENSE file.
|
|
|
|
Because of various ttk limitations this app is an unholy mix of Tk and ttk widgets.
|
|
So can't use ttk's theme support. So have to change colors manually.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import tkinter as tk
|
|
from tkinter import font as tk_font
|
|
from tkinter import ttk
|
|
from typing import Any
|
|
from collections.abc import Callable
|
|
from l10n import translations as tr
|
|
from config import config
|
|
from EDMCLogging import get_main_logger
|
|
from ttkHyperlinkLabel import HyperlinkLabel
|
|
|
|
logger = get_main_logger()
|
|
|
|
if __debug__:
|
|
from traceback import print_exc
|
|
|
|
# Can't use Case matching here due to bug in flake8-naming
|
|
if sys.platform == "win32":
|
|
import ctypes
|
|
from ctypes.wintypes import DWORD, LPCVOID, LPCWSTR
|
|
import win32gui
|
|
import win32con
|
|
AddFontResourceEx = ctypes.windll.gdi32.AddFontResourceExW
|
|
AddFontResourceEx.argtypes = [LPCWSTR, DWORD, LPCVOID]
|
|
AddFontResourceEx.restype = ctypes.c_int
|
|
FR_PRIVATE = 0x10
|
|
FR_NOT_ENUM = 0x20
|
|
font_path = str(config.respath_path / 'EUROCAPS.TTF')
|
|
if not AddFontResourceEx(font_path, FR_PRIVATE, None):
|
|
raise RuntimeError(f"Failed to load font {font_path}")
|
|
dpy = None
|
|
|
|
elif sys.platform == "linux":
|
|
from ctypes import POINTER, Structure, byref, c_char_p, c_int, c_long, c_uint, c_ulong, c_void_p, cdll
|
|
|
|
XID = c_ulong
|
|
Window = XID
|
|
Atom = c_ulong
|
|
Display = c_void_p
|
|
|
|
PropModeReplace = 0
|
|
PropModePrepend = 1
|
|
PropModeAppend = 2
|
|
|
|
MWM_HINTS_FUNCTIONS = 1 << 0
|
|
MWM_HINTS_DECORATIONS = 1 << 1
|
|
MWM_HINTS_INPUT_MODE = 1 << 2
|
|
MWM_HINTS_STATUS = 1 << 3
|
|
MWM_FUNC_ALL = 1 << 0
|
|
MWM_FUNC_RESIZE = 1 << 1
|
|
MWM_FUNC_MOVE = 1 << 2
|
|
MWM_FUNC_MINIMIZE = 1 << 3
|
|
MWM_FUNC_MAXIMIZE = 1 << 4
|
|
MWM_FUNC_CLOSE = 1 << 5
|
|
MWM_DECOR_ALL = 1 << 0
|
|
MWM_DECOR_BORDER = 1 << 1
|
|
MWM_DECOR_RESIZEH = 1 << 2
|
|
MWM_DECOR_TITLE = 1 << 3
|
|
MWM_DECOR_MENU = 1 << 4
|
|
MWM_DECOR_MINIMIZE = 1 << 5
|
|
MWM_DECOR_MAXIMIZE = 1 << 6
|
|
|
|
class MotifWmHints(Structure):
|
|
"""MotifWmHints structure."""
|
|
|
|
_fields_ = [
|
|
('flags', c_ulong),
|
|
('functions', c_ulong),
|
|
('decorations', c_ulong),
|
|
('input_mode', c_long),
|
|
('status', c_ulong),
|
|
]
|
|
|
|
# workaround for https://github.com/EDCD/EDMarketConnector/issues/568
|
|
if not os.getenv("EDMC_NO_UI"):
|
|
try:
|
|
xlib = cdll.LoadLibrary('libX11.so.6')
|
|
XInternAtom = xlib.XInternAtom
|
|
XInternAtom.argtypes = [POINTER(Display), c_char_p, c_int]
|
|
XInternAtom.restype = Atom
|
|
XChangeProperty = xlib.XChangeProperty
|
|
XChangeProperty.argtypes = [POINTER(Display), Window, Atom, Atom, c_int,
|
|
c_int, POINTER(MotifWmHints), c_int]
|
|
XChangeProperty.restype = c_int
|
|
XFlush = xlib.XFlush
|
|
XFlush.argtypes = [POINTER(Display)]
|
|
XFlush.restype = c_int
|
|
XOpenDisplay = xlib.XOpenDisplay
|
|
XOpenDisplay.argtypes = [c_char_p]
|
|
XOpenDisplay.restype = POINTER(Display)
|
|
XQueryTree = xlib.XQueryTree
|
|
XQueryTree.argtypes = [POINTER(Display), Window, POINTER(Window),
|
|
POINTER(Window), POINTER(Window), POINTER(c_uint)]
|
|
XQueryTree.restype = c_int
|
|
dpy = xlib.XOpenDisplay(None)
|
|
if not dpy:
|
|
raise Exception("Can't find your display, can't continue")
|
|
|
|
motif_wm_hints_property = XInternAtom(dpy, b'_MOTIF_WM_HINTS', False)
|
|
motif_wm_hints_normal = MotifWmHints(
|
|
MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS,
|
|
MWM_FUNC_RESIZE | MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE | MWM_FUNC_CLOSE,
|
|
MWM_DECOR_BORDER | MWM_DECOR_RESIZEH | MWM_DECOR_TITLE | MWM_DECOR_MENU | MWM_DECOR_MINIMIZE,
|
|
0, 0
|
|
)
|
|
motif_wm_hints_dark = MotifWmHints(
|
|
MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS,
|
|
MWM_FUNC_RESIZE | MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE | MWM_FUNC_CLOSE,
|
|
0, 0, 0
|
|
)
|
|
except Exception:
|
|
if __debug__:
|
|
print_exc()
|
|
dpy = None
|
|
else:
|
|
dpy = None
|
|
else:
|
|
dpy = None
|
|
|
|
|
|
class _Theme:
|
|
|
|
# Enum ? Remember these are, probably, based on 'value' of a tk
|
|
# RadioButton set. Looking in prefs.py, they *appear* to be hard-coded
|
|
# there as well.
|
|
THEME_DEFAULT = 0
|
|
THEME_DARK = 1
|
|
THEME_TRANSPARENT = 2
|
|
|
|
def __init__(self) -> None:
|
|
self.active: int | None = None # Starts out with no theme
|
|
self.minwidth: int | None = None
|
|
self.widgets: dict[tk.Widget | tk.BitmapImage, set[str]] = {}
|
|
self.widgets_pair: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
|
|
self.defaults: dict[str, Any] = {}
|
|
self.current: dict[str, Any] = {}
|
|
self.default_ui_scale: float | None = None # None == not yet known
|
|
self.startup_ui_scale: int | None = None
|
|
|
|
def register(self, widget: tk.Widget | tk.BitmapImage) -> None: # noqa: CCR001
|
|
# Note widget and children for later application of a theme. Note if
|
|
# the widget has explicit fg or bg attributes.
|
|
if not isinstance(widget, (tk.Widget, tk.BitmapImage)):
|
|
raise TypeError(f'Expected widget, got {type(widget)}')
|
|
if not self.defaults:
|
|
self.defaults = {
|
|
'fg': tk.Label()['foreground'], # SystemButtonText, systemButtonText
|
|
'bg': tk.Label()['background'], # SystemButtonFace, White
|
|
'font': tk.Label()['font'], # TkDefaultFont
|
|
'bitmapfg': tk.BitmapImage()['foreground'], # '-foreground {} {} #000000 #000000'
|
|
'bitmapbg': tk.BitmapImage()['background'], # '-background {} {} {} {}'
|
|
'entryfg': tk.Entry()['foreground'], # SystemWindowText, Black
|
|
'entrybg': tk.Entry()['background'], # SystemWindow, systemWindowBody
|
|
'entryfont': tk.Entry()['font'], # TkTextFont
|
|
'frame': tk.Frame()['background'], # SystemButtonFace, systemWindowBody
|
|
'menufg': tk.Menu()['foreground'], # SystemMenuText,
|
|
'menubg': tk.Menu()['background'], # SystemMenu,
|
|
'menufont': tk.Menu()['font'], # TkTextFont
|
|
}
|
|
|
|
if widget not in self.widgets:
|
|
# No general way to tell whether the user has overridden, so compare against widget-type specific defaults
|
|
attribs = set()
|
|
match widget:
|
|
case tk.BitmapImage():
|
|
if widget['foreground'] not in ('', self.defaults['bitmapfg']):
|
|
attribs.add('fg')
|
|
if widget['background'] not in ('', self.defaults['bitmapbg']):
|
|
attribs.add('bg')
|
|
case tk.Entry() | ttk.Entry():
|
|
if widget['foreground'] not in ('', self.defaults['entryfg']):
|
|
attribs.add('fg')
|
|
if widget['background'] not in ('', self.defaults['entrybg']):
|
|
attribs.add('bg')
|
|
if 'font' in widget.keys() and str(widget['font']) not in ('', self.defaults['entryfont']):
|
|
attribs.add('font')
|
|
case tk.Canvas() | tk.Frame() | ttk.Frame():
|
|
if (('background' in widget.keys() or isinstance(widget, tk.Canvas))
|
|
and widget['background'] not in ('', self.defaults['frame'])):
|
|
attribs.add('bg')
|
|
case HyperlinkLabel():
|
|
pass
|
|
case tk.Menu():
|
|
if widget['foreground'] not in ('', self.defaults['menufg']):
|
|
attribs.add('fg')
|
|
if widget['background'] not in ('', self.defaults['menubg']):
|
|
attribs.add('bg')
|
|
if widget['font'] not in ('', self.defaults['menufont']):
|
|
attribs.add('font')
|
|
case _:
|
|
w_keys = widget.keys() if hasattr(widget, 'keys') else []
|
|
if 'foreground' in w_keys and widget['foreground'] not in ('', self.defaults['fg']):
|
|
attribs.add('fg')
|
|
if 'background' in w_keys and widget['background'] not in ('', self.defaults['bg']):
|
|
attribs.add('bg')
|
|
if 'font' in w_keys and widget['font'] not in ('', self.defaults['font']):
|
|
attribs.add('font')
|
|
self.widgets[widget] = attribs
|
|
|
|
if isinstance(widget, (tk.Frame, ttk.Frame)):
|
|
for child in widget.winfo_children():
|
|
self.register(child) # type: ignore
|
|
|
|
def register_alternate(self, pair: tuple, gridopts: dict) -> None:
|
|
self.widgets_pair.append((pair, gridopts))
|
|
|
|
def button_bind(self, widget: tk.Widget, command: Callable, image: tk.BitmapImage | None = None) -> None:
|
|
widget.bind('<Button-1>', command)
|
|
widget.bind('<Enter>', lambda e: self._enter(e, widget=widget, image=image))
|
|
widget.bind('<Leave>', lambda e: self._leave(e, widget=widget, image=image))
|
|
|
|
def _enter(self, event: tk.Event, widget: tk.Widget | None = None, # noqa: CCR001
|
|
image: tk.BitmapImage | None = None) -> None:
|
|
"""Handle mouse entering a widget or image."""
|
|
if widget is not None:
|
|
# Only apply foreground/background if the widget supports them
|
|
config_keys = widget.keys() if hasattr(widget, 'keys') else []
|
|
kwargs = {}
|
|
if 'foreground' in config_keys and self.current.get('highlightforeground'):
|
|
kwargs['foreground'] = self.current['highlightforeground']
|
|
if 'background' in config_keys and self.current.get('highlightbackground'):
|
|
kwargs['background'] = self.current['highlightbackground']
|
|
if kwargs:
|
|
widget.configure(**kwargs)
|
|
|
|
if image is not None and not isinstance(image, tk.PhotoImage):
|
|
# PhotoImage cannot be configured with fg/bg, skip safely
|
|
try:
|
|
config_keys = image.keys() if hasattr(image, 'keys') else []
|
|
kwargs = {}
|
|
if 'foreground' in config_keys and self.current.get('highlightforeground'):
|
|
kwargs['foreground'] = self.current['highlightforeground']
|
|
if 'background' in config_keys and self.current.get('highlightbackground'):
|
|
kwargs['background'] = self.current['highlightbackground']
|
|
if kwargs:
|
|
image.configure(**kwargs)
|
|
except tk.TclError:
|
|
# silently ignore unsupported image types
|
|
pass
|
|
|
|
def _leave(self, event: tk.Event, widget: tk.Widget | None = None, # noqa: CCR001
|
|
image: tk.BitmapImage | None = None) -> None:
|
|
"""Handle mouse leaving a widget or image."""
|
|
if widget is not None:
|
|
config_keys = widget.keys() if hasattr(widget, 'keys') else []
|
|
kwargs = {}
|
|
if 'foreground' in config_keys and self.current.get('foreground'):
|
|
kwargs['foreground'] = self.current['foreground']
|
|
if 'background' in config_keys and self.current.get('background'):
|
|
kwargs['background'] = self.current['background']
|
|
if kwargs:
|
|
widget.configure(**kwargs)
|
|
|
|
if image is not None and not isinstance(image, tk.PhotoImage):
|
|
# Skip PhotoImage objects; safely handle other types
|
|
try:
|
|
config_keys = image.keys() if hasattr(image, 'keys') else []
|
|
kwargs = {}
|
|
if 'foreground' in config_keys and self.current.get('foreground'):
|
|
kwargs['foreground'] = self.current['foreground']
|
|
if 'background' in config_keys and self.current.get('background'):
|
|
kwargs['background'] = self.current['background']
|
|
if kwargs:
|
|
image.configure(**kwargs)
|
|
except tk.TclError:
|
|
pass
|
|
|
|
# Set up colors
|
|
def _colors(self, root: tk.Tk, theme: int) -> None:
|
|
style = ttk.Style()
|
|
if sys.platform == 'linux':
|
|
style.theme_use('clam')
|
|
|
|
# Default dark theme colors
|
|
if not config.get_str('dark_text'):
|
|
config.set('dark_text', '#ff8000') # "Tangerine" in OSX color picker
|
|
if not config.get_str('dark_highlight'):
|
|
config.set('dark_highlight', 'white')
|
|
|
|
match theme:
|
|
case self.THEME_DEFAULT:
|
|
self.current = {
|
|
'background': style.lookup('TLabel', 'background'),
|
|
'foreground': style.lookup('TLabel', 'foreground'),
|
|
'activebackground': 'SystemHighlight' if sys.platform == 'win32' else style.lookup('TLabel',
|
|
'background',
|
|
['active']),
|
|
'activeforeground': 'SystemHighlightText' if sys.platform == 'win32' else style.lookup('TLabel',
|
|
'foreground',
|
|
['active']),
|
|
'disabledforeground': style.lookup('TLabel', 'foreground', ['disabled']),
|
|
'highlight': 'blue',
|
|
'font': 'TkDefaultFont',
|
|
}
|
|
case _:
|
|
r, g, b = root.winfo_rgb(config.get_str('dark_text'))
|
|
|
|
# Font only supports Latin 1 / Supplement / Extended, and a
|
|
# few General Punctuation and Mathematical Operators
|
|
# LANG: Label for commander name in main window
|
|
use_euro_caps = theme > 1 and not (0x250 < ord(tr.tl('Cmdr')[0]) < 0x3000)
|
|
chosen_font = tk_font.Font(family='Euro Caps', size=10,
|
|
weight=tk_font.NORMAL) if use_euro_caps else 'TkDefaultFont'
|
|
|
|
self.current = {
|
|
'background': 'grey4',
|
|
'foreground': config.get_str('dark_text'),
|
|
'activebackground': config.get_str('dark_text'),
|
|
'activeforeground': 'grey4',
|
|
'disabledforeground': f'#{int(r / 384):02x}{int(g / 384):02x}{int(b / 384):02x}',
|
|
'highlight': config.get_str('dark_highlight'),
|
|
'font': chosen_font,
|
|
}
|
|
|
|
def update(self, widget: tk.Widget) -> None:
|
|
"""
|
|
Apply current theme to a widget and its children.
|
|
|
|
Also, register it for future updates.
|
|
:param widget: Target widget.
|
|
"""
|
|
if not isinstance(widget, (tk.Widget, tk.BitmapImage)):
|
|
raise TypeError(f'Expected widget, got {type(widget)}')
|
|
if not self.current:
|
|
return # No need to call this for widgets created in plugin_app()
|
|
|
|
self.register(widget)
|
|
self._update_widget(widget)
|
|
if isinstance(widget, (tk.Frame, ttk.Frame)):
|
|
for child in widget.winfo_children():
|
|
self._update_widget(child) # type: ignore
|
|
|
|
# Apply current theme to a single widget
|
|
def _update_widget(self, widget: tk.Widget | tk.BitmapImage) -> None: # noqa: CCR001
|
|
if widget not in self.widgets:
|
|
w_class = widget.winfo_class() if isinstance(widget, tk.Widget) else ''
|
|
w_keys = widget.keys() if isinstance(widget, tk.Widget) else []
|
|
w_text = widget["text"] if "text" in w_keys else ""
|
|
raise ValueError(f'{w_class} {widget} "{w_text}"')
|
|
|
|
attribs = self.widgets.get(widget, set())
|
|
|
|
try:
|
|
match widget:
|
|
case tk.BitmapImage():
|
|
if 'fg' not in attribs:
|
|
widget['foreground'] = self.current['foreground']
|
|
if 'bg' not in attribs:
|
|
widget['background'] = self.current['background']
|
|
|
|
case _ if 'cursor' in widget.keys() and str(widget['cursor']) not in ('', 'arrow'):
|
|
# Hack - highlight widgets like HyperlinkLabel with a non-default cursor
|
|
if 'fg' not in attribs:
|
|
widget['foreground'] = self.current['highlight']
|
|
if 'insertbackground' in widget.keys(): # tk.Entry
|
|
widget['insertbackground'] = self.current['foreground']
|
|
if 'bg' not in attribs:
|
|
widget['background'] = self.current['background']
|
|
if 'highlightbackground' in widget.keys(): # tk.Entry
|
|
widget['highlightbackground'] = self.current['background']
|
|
if 'font' not in attribs:
|
|
widget['font'] = self.current['font']
|
|
|
|
case _ if 'activeforeground' in widget.keys():
|
|
# e.g. tk.Button, tk.Label, tk.Menu
|
|
if 'fg' not in attribs:
|
|
widget['foreground'] = self.current['foreground']
|
|
widget['activeforeground'] = self.current['activeforeground']
|
|
widget['disabledforeground'] = self.current['disabledforeground']
|
|
if 'bg' not in attribs:
|
|
widget['background'] = self.current['background']
|
|
widget['activebackground'] = self.current['activebackground']
|
|
if 'font' not in attribs:
|
|
widget['font'] = self.current['font']
|
|
|
|
case _ if 'foreground' in widget.keys():
|
|
# e.g. ttk.Label
|
|
if 'fg' not in attribs:
|
|
widget['foreground'] = self.current['foreground']
|
|
if 'bg' not in attribs:
|
|
widget['background'] = self.current['background']
|
|
if 'font' not in attribs:
|
|
widget['font'] = self.current['font']
|
|
|
|
case _ if 'background' in widget.keys() or isinstance(widget, tk.Canvas):
|
|
# e.g. Frame, Canvas
|
|
if 'bg' not in attribs:
|
|
widget['background'] = self.current['background']
|
|
widget['highlightbackground'] = self.current['disabledforeground']
|
|
|
|
except Exception:
|
|
logger.exception(f'Plugin widget issue? {widget=}')
|
|
|
|
# Apply configured theme
|
|
def apply(self, root: tk.Tk) -> None: # noqa: CCR001
|
|
theme = config.get_int('theme')
|
|
self._colors(root, theme)
|
|
|
|
# Apply colors
|
|
for widget in list(self.widgets.keys()):
|
|
if isinstance(widget, tk.Widget) and not widget.winfo_exists():
|
|
self.widgets.pop(widget) # has been destroyed
|
|
else:
|
|
self._update_widget(widget)
|
|
|
|
# Switch menus
|
|
for pair, gridopts in self.widgets_pair:
|
|
for widget in pair:
|
|
if isinstance(widget, tk.Widget):
|
|
widget.grid_remove()
|
|
|
|
if isinstance(pair[0], tk.Menu):
|
|
match theme:
|
|
case self.THEME_DEFAULT:
|
|
root['menu'] = pair[0]
|
|
case _: # Dark *or* Transparent
|
|
root['menu'] = ''
|
|
pair[theme].grid(**gridopts)
|
|
else:
|
|
pair[theme].grid(**gridopts)
|
|
|
|
if self.active == theme:
|
|
return # Don't need to mess with the window manager
|
|
self.active = theme
|
|
|
|
if sys.platform == 'win32':
|
|
root.overrideredirect(theme != self.THEME_DEFAULT)
|
|
root.attributes("-transparentcolor", 'grey4' if theme == self.THEME_TRANSPARENT else '')
|
|
|
|
root.withdraw()
|
|
root.update_idletasks() # Size and windows styles get recalculated here
|
|
hwnd = win32gui.GetParent(root.winfo_id())
|
|
win32gui.SetWindowLong(
|
|
hwnd,
|
|
win32con.GWL_STYLE,
|
|
win32gui.GetWindowLong(hwnd, win32con.GWL_STYLE) & ~win32con.WS_MAXIMIZEBOX
|
|
)
|
|
|
|
ex_style = win32con.WS_EX_APPWINDOW
|
|
if theme == self.THEME_TRANSPARENT:
|
|
ex_style |= win32con.WS_EX_LAYERED
|
|
|
|
win32gui.SetWindowLong(hwnd, win32con.GWL_EXSTYLE, ex_style)
|
|
root.deiconify()
|
|
root.wait_visibility() # need main window to be displayed before returning
|
|
else:
|
|
root.withdraw()
|
|
root.update_idletasks() # Size gets recalculated here
|
|
if dpy:
|
|
xroot, parent, children = Window(), Window(), Window()
|
|
nchildren = c_uint()
|
|
XQueryTree(dpy, root.winfo_id(), byref(xroot), byref(parent), byref(children), byref(nchildren))
|
|
wm_hints = motif_wm_hints_normal if theme == self.THEME_DEFAULT else motif_wm_hints_dark
|
|
XChangeProperty(dpy, parent, motif_wm_hints_property, motif_wm_hints_property, 32, PropModeReplace,
|
|
wm_hints, 5)
|
|
XFlush(dpy)
|
|
else:
|
|
root.overrideredirect(theme != self.THEME_DEFAULT)
|
|
root.deiconify()
|
|
root.wait_visibility() # need main window to be displayed before returning
|
|
|
|
if not self.minwidth:
|
|
self.minwidth = root.winfo_width() # Minimum width = width on first creation
|
|
root.minsize(self.minwidth, -1)
|
|
|
|
|
|
# Singleton
|
|
theme = _Theme()
|