anki/qt/aqt/__init__.py

635 lines
20 KiB
Python
Raw Normal View History

2019-02-05 04:59:03 +01:00
# Copyright: Ankitects Pty Ltd and contributors
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
from __future__ import annotations
2021-10-28 10:46:45 +02:00
import sys
if sys.version_info[0] < 3 or sys.version_info[1] < 9:
raise Exception("Anki requires Python 3.9+")
# ensure unicode filenames are supported
try:
"テスト".encode(sys.getfilesystemencoding())
except UnicodeEncodeError as exc:
raise Exception("Anki requires a UTF-8 locale.") from exc
from .package import packaged_build_setup
packaged_build_setup()
import argparse
import builtins
2020-11-25 02:54:41 +01:00
import cProfile
2019-12-20 10:19:03 +01:00
import getpass
import locale
import os
2019-12-20 10:19:03 +01:00
import tempfile
import traceback
from typing import Any, Callable, Optional, cast
import anki.lang
from anki._backend import RustBackend
from anki.buildinfo import version as _version
from anki.collection import Collection
2012-12-21 10:04:26 +01:00
from anki.consts import HELP_SITE
from anki.utils import checksum, is_lin, is_mac
from aqt import gui_hooks
2019-12-20 10:19:03 +01:00
from aqt.qt import *
2021-10-10 06:27:28 +02:00
from aqt.utils import TR, tr
# compat aliases
anki.version = _version # type: ignore
anki.Collection = Collection # type: ignore
# we want to be able to print unicode debug info to console without
# fear of a traceback on systems with the console set to ASCII
2020-08-06 01:05:26 +02:00
try:
sys.stdout.reconfigure(encoding="utf-8") # type: ignore
sys.stderr.reconfigure(encoding="utf-8") # type: ignore
except AttributeError:
# on Windows without console, NullWriter doesn't support this
pass
2019-12-23 01:34:10 +01:00
appVersion = _version
appWebsite = "https://apps.ankiweb.net/"
appDonate = "https://apps.ankiweb.net/support/"
2020-02-29 12:43:37 +01:00
appShared = "https://ankiweb.net/shared/"
2019-12-23 01:34:10 +01:00
appUpdate = "https://ankiweb.net/update/desktop"
appHelpSite = HELP_SITE
2019-12-19 00:58:16 +01:00
2019-12-23 01:34:10 +01:00
from aqt.main import AnkiQt # isort:skip
from aqt.profiles import ProfileManager, VideoDriver # isort:skip
2019-12-19 00:58:16 +01:00
2020-11-25 02:54:41 +01:00
profiler: Optional[cProfile.Profile] = None
2019-12-23 01:34:10 +01:00
mw: Optional[AnkiQt] = None # set on init
2021-10-05 00:35:35 +02:00
import aqt.forms
# Dialog manager
##########################################################################
# ensures only one copy of the window is open at once, and provides
# a way for dialogs to clean up asynchronously when collection closes
# to integrate a new window:
# - add it to _dialogs
# - define close behaviour, by either:
# -- setting silentlyClose=True to have it close immediately
# -- define a closeWithCallback() method
# - have the window opened via aqt.dialogs.open(<name>, self)
# - have a method reopen(*args), called if the user ask to open the window a second time. Arguments passed are the same than for original opening.
2019-12-23 01:34:10 +01:00
# - make preferences modal? cmd+q does wrong thing
2021-03-24 04:17:12 +01:00
from aqt import addcards, addons, browser, editcurrent, filtered_deck # isort:skip
from aqt import stats, about, preferences, mediasync # isort:skip
2019-12-23 01:34:10 +01:00
class DialogManager:
_dialogs: dict[str, list] = {
"AddCards": [addcards.AddCards, None],
2020-12-26 18:07:37 +01:00
"AddonsDialog": [addons.AddonsDialog, None],
"Browser": [browser.Browser, None],
"EditCurrent": [editcurrent.EditCurrent, None],
2021-03-24 04:17:12 +01:00
"FilteredDeckConfigDialog": [filtered_deck.FilteredDeckConfigDialog, None],
"DeckStats": [stats.DeckStats, None],
"NewDeckStats": [stats.NewDeckStats, None],
"About": [about.show, None],
"Preferences": [preferences.Preferences, None],
2020-02-04 02:48:51 +01:00
"sync_log": [mediasync.MediaSyncDialog, None],
}
def open(self, name: str, *args: Any, **kwargs: Any) -> Any:
(creator, instance) = self._dialogs[name]
if instance:
if instance.windowState() & Qt.WindowState.WindowMinimized:
instance.setWindowState(
instance.windowState() & ~Qt.WindowState.WindowMinimized
)
instance.activateWindow()
instance.raise_()
2019-12-23 01:34:10 +01:00
if hasattr(instance, "reopen"):
instance.reopen(*args, **kwargs)
else:
instance = creator(*args, **kwargs)
self._dialogs[name][1] = instance
gui_hooks.dialog_manager_did_open_dialog(self, name, instance)
return instance
2021-02-01 14:28:21 +01:00
def markClosed(self, name: str) -> None:
self._dialogs[name] = [self._dialogs[name][0], None]
2021-02-01 14:28:21 +01:00
def allClosed(self) -> bool:
return not any(x[1] for x in self._dialogs.values())
def closeAll(self, onsuccess: Callable[[], None]) -> Optional[bool]:
# can we close immediately?
if self.allClosed():
onsuccess()
return None
# ask all windows to close and await a reply
for (name, (creator, instance)) in self._dialogs.items():
if not instance:
continue
2021-02-01 14:28:21 +01:00
def callback() -> None:
if self.allClosed():
onsuccess()
else:
# still waiting for others to close
pass
if getattr(instance, "silentlyClose", False):
instance.close()
callback()
else:
instance.closeWithCallback(callback)
return True
def register_dialog(
self, name: str, creator: Union[Callable, type], instance: Optional[Any] = None
2021-02-02 14:30:53 +01:00
) -> None:
"""Allows add-ons to register a custom dialog to be managed by Anki's dialog
manager, which ensures that only one copy of the window is open at once,
and that the dialog cleans up asynchronously when the collection closes
2020-08-31 05:29:28 +02:00
Please note that dialogs added in this manner need to define a close behavior
by either:
2020-08-31 05:29:28 +02:00
- setting `dialog.silentlyClose = True` to have it close immediately
- define a `dialog.closeWithCallback()` method that is called when closed
by the dialog manager
2020-08-31 05:29:28 +02:00
TODO?: Implement more restrictive type check to ensure these requirements
are met
2020-08-31 05:29:28 +02:00
Arguments:
name {str} -- Name/identifier of the dialog in question
creator {Union[Callable, type]} -- A class or function to create new
dialog instances with
2020-08-31 05:29:28 +02:00
Keyword Arguments:
instance {Optional[Any]} -- An optional existing instance of the dialog
(default: {None})
"""
self._dialogs[name] = [creator, instance]
2019-12-23 01:34:10 +01:00
dialogs = DialogManager()
# Language handling
##########################################################################
# Qt requires its translator to be installed before any GUI widgets are
2020-11-18 04:22:51 +01:00
# loaded, and we need the Qt language to match the i18n language or
# translated shortcuts will not work.
2020-03-14 00:45:00 +01:00
# A reference to the Qt translator needs to be held to prevent it from
# being immediately deallocated.
2019-12-20 06:07:40 +01:00
_qtrans: Optional[QTranslator] = None
2019-12-23 01:34:10 +01:00
2020-03-14 00:45:00 +01:00
def setupLangAndBackend(
pm: ProfileManager,
app: QApplication,
force: Optional[str] = None,
firstTime: bool = False,
2020-03-14 00:45:00 +01:00
) -> RustBackend:
global _qtrans
try:
2019-12-23 01:34:10 +01:00
locale.setlocale(locale.LC_ALL, "")
except:
pass
2019-12-23 01:34:10 +01:00
# add _ and ngettext globals used by legacy code
2021-02-02 14:30:53 +01:00
def fn__(arg) -> None: # type: ignore
print("".join(traceback.format_stack()[-2]))
print("_ global will break in the future; please see anki/lang.py")
return arg
2019-12-23 01:34:10 +01:00
2021-02-02 14:30:53 +01:00
def fn_ngettext(a, b, c) -> None: # type: ignore
print("".join(traceback.format_stack()[-2]))
print("ngettext global will break in the future; please see anki/lang.py")
return b
2019-12-23 01:34:10 +01:00
builtins.__dict__["_"] = fn__
builtins.__dict__["ngettext"] = fn_ngettext
# get lang and normalize into ja/zh-CN form
if firstTime:
lang = pm.meta["defaultLang"]
else:
lang = force or pm.meta["defaultLang"]
lang = anki.lang.lang_to_disk_lang(lang)
if not firstTime:
# set active language
anki.lang.set_lang(lang)
# switch direction for RTL languages
if anki.lang.is_rtl(lang):
app.setLayoutDirection(Qt.LayoutDirection.RightToLeft)
else:
app.setLayoutDirection(Qt.LayoutDirection.LeftToRight)
# load qt translations
_qtrans = QTranslator()
if is_mac and getattr(sys, "frozen", False):
2021-10-28 10:46:45 +02:00
qt_dir = os.path.join(sys.prefix, "../Resources/qt_translations")
else:
if qtmajor == 5:
qt_dir = QLibraryInfo.location(QLibraryInfo.TranslationsPath) # type: ignore
else:
qt_dir = QLibraryInfo.path(QLibraryInfo.LibraryPath.TranslationsPath)
qt_lang = lang.replace("-", "_")
if _qtrans.load(f"qtbase_{qt_lang}", qt_dir):
app.installTranslator(_qtrans)
2020-03-14 00:45:00 +01:00
return anki.lang.current_i18n
2019-12-23 01:34:10 +01:00
# App initialisation
##########################################################################
2019-12-23 01:34:10 +01:00
class AnkiApp(QApplication):
# Single instance support on Win32/Linux
##################################################
appMsg = pyqtSignal(str)
KEY = f"anki{checksum(getpass.getuser())}"
TMOUT = 30000
def __init__(self, argv: list[str]) -> None:
QApplication.__init__(self, argv)
self._argv = argv
2021-02-01 14:28:21 +01:00
def secondInstance(self) -> bool:
# we accept only one command line argument. if it's missing, send
# a blank screen to just raise the existing window
opts, args = parseArgs(self._argv)
buf = "raise"
if args and args[0]:
buf = os.path.abspath(args[0])
if self.sendMsg(buf):
print("Already running; reusing existing instance.")
return True
else:
# send failed, so we're the first instance or the
# previous instance died
QLocalServer.removeServer(self.KEY)
self._srv = QLocalServer(self)
qconnect(self._srv.newConnection, self.onRecv)
self._srv.listen(self.KEY)
return False
2021-02-02 14:30:53 +01:00
def sendMsg(self, txt: str) -> bool:
sock = QLocalSocket(self)
sock.connectToServer(self.KEY, QIODevice.OpenModeFlag.WriteOnly)
if not sock.waitForConnected(self.TMOUT):
# first instance or previous instance dead
return False
sock.write(txt.encode("utf8"))
if not sock.waitForBytesWritten(self.TMOUT):
# existing instance running but hung
2019-12-23 01:34:10 +01:00
QMessageBox.warning(
None,
2021-03-26 04:48:26 +01:00
tr.qt_misc_anki_is_running(),
tr.qt_misc_if_instance_is_not_responding(),
2019-12-23 01:34:10 +01:00
)
sys.exit(1)
sock.disconnectFromServer()
return True
2021-02-01 14:28:21 +01:00
def onRecv(self) -> None:
sock = self._srv.nextPendingConnection()
if not sock.waitForReadyRead(self.TMOUT):
sys.stderr.write(sock.errorString())
return
path = bytes(cast(bytes, sock.readAll())).decode("utf8")
self.appMsg.emit(path) # type: ignore
sock.disconnectFromServer()
# OS X file/url handler
##################################################
2021-02-02 14:30:53 +01:00
def event(self, evt: QEvent) -> bool:
if evt.type() == QEvent.Type.FileOpen:
self.appMsg.emit(evt.file() or "raise") # type: ignore
return True
return QApplication.event(self, evt)
2019-12-23 01:34:10 +01:00
def parseArgs(argv: list[str]) -> tuple[argparse.Namespace, list[str]]:
"Returns (opts, args)."
# py2app fails to strip this in some instances, then anki dies
# as there's no such profile
if is_mac and len(argv) > 1 and argv[1].startswith("-psn"):
argv = [argv[0]]
parser = argparse.ArgumentParser(description=f"Anki {appVersion}")
parser.usage = "%(prog)s [OPTIONS] [file to import/add-on to install]"
parser.add_argument("-b", "--base", help="path to base folder", default="")
parser.add_argument("-p", "--profile", help="profile name to load", default="")
parser.add_argument("-l", "--lang", help="interface language (en, de, etc)")
parser.add_argument(
2021-01-11 05:11:18 +01:00
"-v", "--version", help="print the Anki version and exit", action="store_true"
)
parser.add_argument(
"--safemode", help="disable add-ons and automatic syncing", action="store_true"
)
parser.add_argument(
"--syncserver",
help="skip GUI and start a local sync server",
action="store_true",
)
return parser.parse_known_args(argv[1:])
2019-12-23 01:34:10 +01:00
2021-02-02 14:30:53 +01:00
def setupGL(pm: aqt.profiles.ProfileManager) -> None:
if is_mac:
return
driver = pm.video_driver()
# work around pyqt loading wrong GL library
if is_lin:
import ctypes
2019-12-23 01:34:10 +01:00
ctypes.CDLL("libGL.so.1", ctypes.RTLD_GLOBAL)
# catch opengl errors
2021-02-02 14:30:53 +01:00
def msgHandler(category: Any, ctx: Any, msg: Any) -> None:
if category == QtMsgType.QtDebugMsg:
category = "debug"
elif category == QtMsgType.QtInfoMsg:
category = "info"
elif category == QtMsgType.QtWarningMsg:
category = "warning"
elif category == QtMsgType.QtCriticalMsg:
category = "critical"
elif category == QtMsgType.QtDebugMsg:
category = "debug"
elif category == QtMsgType.QtFatalMsg:
category = "fatal"
else:
category = "unknown"
context = ""
if ctx.file:
context += f"{ctx.file}:"
if ctx.line:
context += f"{ctx.line},"
if ctx.function:
context += f"{ctx.function}"
if context:
context = f"'{context}'"
if "Failed to create OpenGL context" in msg:
2019-12-23 01:34:10 +01:00
QMessageBox.critical(
None,
2021-03-26 04:48:26 +01:00
tr.qt_misc_error(),
tr.qt_misc_error_loading_graphics_driver(
mode=driver.value,
context=context,
),
2019-12-23 01:34:10 +01:00
)
pm.set_video_driver(driver.next())
return
else:
print(f"Qt {category}: {msg} {context}")
2019-12-23 01:34:10 +01:00
qInstallMessageHandler(msgHandler)
# ignore set graphics driver on Qt6 for now
if qtmajor > 5:
return
if driver == VideoDriver.OpenGL:
pass
else:
if is_win:
os.environ["QT_OPENGL"] = driver.value
elif is_mac:
QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_UseSoftwareOpenGL)
elif is_lin:
os.environ["QT_XCB_FORCE_SOFTWARE_OPENGL"] = "1"
2019-12-23 01:34:10 +01:00
PROFILE_CODE = os.environ.get("ANKI_PROFILE_CODE")
2021-02-01 14:28:21 +01:00
def write_profile_results() -> None:
profiler.disable()
profile = os.path.join(os.environ.get("BUILD_WORKSPACE_DIRECTORY", ""), "anki.prof")
profiler.dump_stats(profile)
profiler.dump_stats("anki.prof")
print("profile stats written to anki.prof")
print("use 'bazel run qt:profile' to explore")
2021-02-01 14:28:21 +01:00
def run() -> None:
2021-10-28 10:46:45 +02:00
print("Preparing to run...")
2014-07-07 03:41:56 +02:00
try:
_run()
except Exception as e:
2018-09-24 08:24:11 +02:00
traceback.print_exc()
2019-12-23 01:34:10 +01:00
QMessageBox.critical(
None,
"Startup Error",
f"Please notify support of this error:\n\n{traceback.format_exc()}",
2019-12-23 01:34:10 +01:00
)
2014-07-07 03:41:56 +02:00
def _run(argv: Optional[list[str]] = None, exec: bool = True) -> Optional[AnkiApp]:
"""Start AnkiQt application or reuse an existing instance if one exists.
If the function is invoked with exec=False, the AnkiQt will not enter
the main event loop - instead the application object will be returned.
The 'exec' and 'argv' arguments will be useful for testing purposes.
If no 'argv' is supplied then 'sys.argv' will be used.
"""
global mw
global profiler
if argv is None:
argv = sys.argv
# parse args
opts, args = parseArgs(argv)
if opts.version:
2021-01-11 05:11:18 +01:00
print(f"Anki {appVersion}")
2021-02-01 14:28:21 +01:00
return None
2021-01-11 05:11:18 +01:00
elif opts.syncserver:
from anki.syncserver import serve
serve()
2021-02-01 14:28:21 +01:00
return None
if PROFILE_CODE:
profiler = cProfile.Profile()
profiler.enable()
if (
getattr(sys, "frozen", False)
and os.getenv("QT_QPA_PLATFORM") == "wayland"
and not os.getenv("ANKI_WAYLAND")
):
# users need to opt in to wayland support, given the issues it has
print("Wayland support is disabled by default due to bugs.")
print("You can force it on with an env var: ANKI_WAYLAND=1")
os.environ["QT_QPA_PLATFORM"] = "xcb"
# default to specified/system language before getting user's preference so that we can localize some more strings
lang = anki.lang.get_def_lang(opts.lang)
anki.lang.set_lang(lang[1])
# profile manager
pm = None
try:
pm = ProfileManager(opts.base)
pmLoadResult = pm.setupMeta()
except:
# will handle below
traceback.print_exc()
pm = None
if pm:
# gl workarounds
setupGL(pm)
# apply user-provided scale factor
os.environ["QT_SCALE_FACTOR"] = str(pm.uiScale())
# opt in to full hidpi support?
if not os.environ.get("ANKI_NOHIGHDPI") and qtmajor == 5:
QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_EnableHighDpiScaling) # type: ignore
QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_UseHighDpiPixmaps) # type: ignore
2019-12-17 09:43:32 +01:00
os.environ["QT_ENABLE_HIGHDPI_SCALING"] = "1"
os.environ["QT_SCALE_FACTOR_ROUNDING_POLICY"] = "PassThrough"
# Opt into software rendering. Useful for buggy systems.
if os.environ.get("ANKI_SOFTWAREOPENGL"):
QCoreApplication.setAttribute(Qt.ApplicationAttribute.AA_UseSoftwareOpenGL)
if (
is_win
and qtmajor == 5
and (qtminor == 14 or (qtminor == 15 and qtpoint == 0))
and "QT_QPA_PLATFORM" not in os.environ
):
2020-07-24 03:57:37 +02:00
os.environ["QT_QPA_PLATFORM"] = "windows:altgr"
# create the app
QCoreApplication.setApplicationName("Anki")
QGuiApplication.setDesktopFileName("anki.desktop")
app = AnkiApp(argv)
if app.secondInstance():
# we've signaled the primary instance, so we should close
2021-02-01 14:28:21 +01:00
return None
if not pm:
QMessageBox.critical(
None,
2021-03-26 04:48:26 +01:00
tr.qt_misc_error(),
tr.profiles_could_not_create_data_folder(),
)
2021-02-01 14:28:21 +01:00
return None
# disable icons on mac; this must be done before window created
if is_mac:
app.setAttribute(Qt.ApplicationAttribute.AA_DontShowIconsInMenus)
2019-12-17 08:59:19 +01:00
# disable help button in title bar on qt versions that support it
if is_win and qtmajor == 5 and qtminor >= 10:
QApplication.setAttribute(Qt.AA_DisableWindowContextHelpButton) # type: ignore
2019-12-17 08:59:19 +01:00
# proxy configured?
from urllib.request import getproxies, proxy_bypass
2019-12-23 01:34:10 +01:00
disable_proxies = False
try:
if "http" in getproxies():
# if it's not set up to bypass localhost, we'll
# need to disable proxies in the webviews
if not proxy_bypass("127.0.0.1"):
disable_proxies = True
except UnicodeDecodeError:
# proxy_bypass can't handle unicode in hostnames; assume we need
# to disable proxies
disable_proxies = True
if disable_proxies:
print("webview proxy use disabled")
proxy = QNetworkProxy()
proxy.setType(QNetworkProxy.ProxyType.NoProxy)
QNetworkProxy.setApplicationProxy(proxy)
# we must have a usable temp dir
try:
tempfile.gettempdir()
except:
QMessageBox.critical(
2019-12-23 01:34:10 +01:00
None,
2021-03-26 04:48:26 +01:00
tr.qt_misc_error(),
tr.qt_misc_no_temp_folder(),
2019-12-23 01:34:10 +01:00
)
2021-02-01 14:28:21 +01:00
return None
# make image resources available
from aqt.utils import aqt_data_folder
QDir.addSearchPath("icons", os.path.join(aqt_data_folder(), "qt", "icons"))
if pmLoadResult.firstTime:
pm.setDefaultLang(lang[0])
if pmLoadResult.loadError:
QMessageBox.warning(
2019-12-23 01:34:10 +01:00
None,
2021-03-26 04:48:26 +01:00
tr.profiles_prefs_corrupt_title(),
tr.profiles_prefs_file_is_corrupt(),
2019-12-23 01:34:10 +01:00
)
if opts.profile:
pm.openProfile(opts.profile)
2020-03-14 00:45:00 +01:00
# i18n & backend
backend = setupLangAndBackend(pm, app, opts.lang, pmLoadResult.firstTime)
driver = pm.video_driver()
if is_lin and driver == VideoDriver.OpenGL:
2018-12-18 10:29:34 +01:00
from aqt.utils import gfxDriverIsBroken
2019-12-23 01:34:10 +01:00
2018-12-18 10:29:34 +01:00
if gfxDriverIsBroken():
pm.set_video_driver(driver.next())
2019-12-23 01:34:10 +01:00
QMessageBox.critical(
None,
2021-03-26 04:48:26 +01:00
tr.qt_misc_error(),
tr.qt_misc_incompatible_video_driver(),
2019-12-23 01:34:10 +01:00
)
2018-12-18 10:29:34 +01:00
sys.exit(1)
# load the main window
import aqt.main
2019-12-23 01:34:10 +01:00
2020-03-14 00:45:00 +01:00
mw = aqt.main.AnkiQt(app, pm, backend, opts, args)
if exec:
2021-10-28 10:46:45 +02:00
print("Starting main loop...")
app.exec()
else:
return app
if PROFILE_CODE:
write_profile_results()
2021-02-01 14:28:21 +01:00
return None