2019-02-05 04:59:03 +01:00
|
|
|
# Copyright: Ankitects Pty Ltd and contributors
|
2012-12-21 08:51:59 +01:00
|
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
|
2019-12-20 10:19:03 +01:00
|
|
|
import faulthandler
|
|
|
|
import gc
|
2020-01-03 17:57:33 +01:00
|
|
|
import os
|
2019-12-20 10:19:03 +01:00
|
|
|
import platform
|
2013-10-18 00:48:45 +02:00
|
|
|
import re
|
|
|
|
import signal
|
2016-07-04 05:22:35 +02:00
|
|
|
import time
|
2019-12-20 10:19:03 +01:00
|
|
|
import zipfile
|
|
|
|
from argparse import Namespace
|
2017-01-08 10:29:57 +01:00
|
|
|
from threading import Thread
|
2019-12-20 10:19:03 +01:00
|
|
|
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
|
|
|
|
|
2013-05-23 07:04:40 +02:00
|
|
|
from send2trash import send2trash
|
2019-12-20 10:19:03 +01:00
|
|
|
|
2013-10-18 00:48:45 +02:00
|
|
|
import aqt
|
2019-12-20 10:19:03 +01:00
|
|
|
import aqt.mediasrv
|
2020-01-02 10:43:19 +01:00
|
|
|
import aqt.mpv
|
2013-10-18 00:48:45 +02:00
|
|
|
import aqt.progress
|
2020-01-02 10:43:19 +01:00
|
|
|
import aqt.sound
|
2013-10-18 00:48:45 +02:00
|
|
|
import aqt.stats
|
2019-12-20 10:19:03 +01:00
|
|
|
import aqt.toolbar
|
|
|
|
import aqt.webview
|
2020-01-13 04:57:51 +01:00
|
|
|
from anki import hooks
|
2019-12-20 10:19:03 +01:00
|
|
|
from anki.collection import _Collection
|
2020-01-15 04:49:26 +01:00
|
|
|
from anki.hooks import runHook
|
2019-03-04 02:58:34 +01:00
|
|
|
from anki.lang import _, ngettext
|
2019-12-20 10:19:03 +01:00
|
|
|
from anki.storage import Collection
|
|
|
|
from anki.utils import devMode, ids2str, intTime, isMac, isWin, splitFields
|
2020-01-13 05:38:05 +01:00
|
|
|
from aqt import gui_hooks
|
2020-01-19 02:31:09 +01:00
|
|
|
from aqt.addons import DownloadLogEntry, check_and_prompt_for_updates, show_log_to_user
|
2019-12-20 10:19:03 +01:00
|
|
|
from aqt.profiles import ProfileManager as ProfileManagerType
|
|
|
|
from aqt.qt import *
|
|
|
|
from aqt.qt import sip
|
2020-01-19 01:05:37 +01:00
|
|
|
from aqt.taskman import TaskManager
|
2019-12-23 01:34:10 +01:00
|
|
|
from aqt.utils import (
|
|
|
|
askUser,
|
|
|
|
checkInvalidFilename,
|
|
|
|
getFile,
|
|
|
|
getOnlyText,
|
|
|
|
openHelp,
|
|
|
|
openLink,
|
|
|
|
restoreGeom,
|
|
|
|
restoreState,
|
|
|
|
saveGeom,
|
|
|
|
showInfo,
|
|
|
|
showText,
|
|
|
|
showWarning,
|
|
|
|
tooltip,
|
|
|
|
)
|
2013-12-06 05:27:13 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
class AnkiQt(QMainWindow):
|
2019-12-20 09:43:52 +01:00
|
|
|
col: _Collection
|
|
|
|
pm: ProfileManagerType
|
|
|
|
web: aqt.webview.AnkiWebView
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
app: QApplication,
|
|
|
|
profileManager: ProfileManagerType,
|
|
|
|
opts: Namespace,
|
|
|
|
args: List[Any],
|
|
|
|
) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
QMainWindow.__init__(self)
|
|
|
|
self.state = "startup"
|
2017-10-03 04:12:57 +02:00
|
|
|
self.opts = opts
|
2019-12-16 10:46:40 +01:00
|
|
|
self.col: Optional[_Collection] = None
|
2020-01-19 01:05:37 +01:00
|
|
|
self.taskman = TaskManager()
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.mw = self
|
|
|
|
self.app = app
|
2019-12-19 02:39:40 +01:00
|
|
|
self.pm = profileManager
|
2012-12-21 08:51:59 +01:00
|
|
|
# init rest of app
|
2017-01-17 04:53:02 +01:00
|
|
|
self.safeMode = self.app.queryKeyboardModifiers() & Qt.ShiftModifier
|
2012-12-21 08:51:59 +01:00
|
|
|
try:
|
|
|
|
self.setupUI()
|
2020-01-04 04:34:16 +01:00
|
|
|
self.setupAddons(args)
|
2012-12-21 08:51:59 +01:00
|
|
|
except:
|
|
|
|
showInfo(_("Error during startup:\n%s") % traceback.format_exc())
|
|
|
|
sys.exit(1)
|
2013-05-17 08:32:17 +02:00
|
|
|
# must call this after ui set up
|
|
|
|
if self.safeMode:
|
2019-12-23 01:34:10 +01:00
|
|
|
tooltip(
|
|
|
|
_(
|
|
|
|
"Shift key was held down. Skipping automatic "
|
|
|
|
"syncing and add-on loading."
|
|
|
|
)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
# were we given a file to import?
|
2020-01-04 04:34:16 +01:00
|
|
|
if args and args[0] and not self._isAddon(args[0]):
|
2016-05-12 06:45:35 +02:00
|
|
|
self.onAppMsg(args[0])
|
2012-12-21 08:51:59 +01:00
|
|
|
# Load profile in a timer so we can let the window finish init and not
|
|
|
|
# close on profile load error.
|
2019-04-16 05:24:38 +02:00
|
|
|
if isWin:
|
|
|
|
fn = self.setupProfileAfterWebviewsLoaded
|
|
|
|
else:
|
|
|
|
fn = self.setupProfile
|
|
|
|
self.progress.timer(10, fn, False, requiresCollection=False)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupUI(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.col = None
|
2017-01-08 04:38:12 +01:00
|
|
|
self.setupCrashLog()
|
2017-01-13 07:20:39 +01:00
|
|
|
self.disableGC()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setupAppMsg()
|
|
|
|
self.setupKeys()
|
|
|
|
self.setupThreads()
|
2017-07-28 08:19:06 +02:00
|
|
|
self.setupMediaServer()
|
2017-10-05 05:48:24 +02:00
|
|
|
self.setupSound()
|
2019-03-06 14:18:26 +01:00
|
|
|
self.setupSpellCheck()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setupMainWindow()
|
|
|
|
self.setupSystemSpecific()
|
|
|
|
self.setupStyle()
|
|
|
|
self.setupMenus()
|
|
|
|
self.setupProgress()
|
|
|
|
self.setupErrorHandler()
|
|
|
|
self.setupSignals()
|
|
|
|
self.setupAutoUpdate()
|
2013-05-22 05:27:37 +02:00
|
|
|
self.setupHooks()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setupRefreshTimer()
|
|
|
|
self.updateTitleBar()
|
|
|
|
# screens
|
|
|
|
self.setupDeckBrowser()
|
|
|
|
self.setupOverview()
|
|
|
|
self.setupReviewer()
|
|
|
|
|
2019-04-16 05:24:38 +02:00
|
|
|
def setupProfileAfterWebviewsLoaded(self):
|
|
|
|
for w in (self.web, self.bottomWeb):
|
|
|
|
if not w._domDone:
|
2019-12-23 01:34:10 +01:00
|
|
|
self.progress.timer(
|
|
|
|
10,
|
|
|
|
self.setupProfileAfterWebviewsLoaded,
|
|
|
|
False,
|
|
|
|
requiresCollection=False,
|
|
|
|
)
|
2019-04-16 05:24:38 +02:00
|
|
|
return
|
|
|
|
else:
|
|
|
|
w.requiresCol = True
|
|
|
|
|
|
|
|
self.setupProfile()
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Profiles
|
|
|
|
##########################################################################
|
|
|
|
|
2017-08-16 11:45:39 +02:00
|
|
|
class ProfileManager(QMainWindow):
|
|
|
|
onClose = pyqtSignal()
|
|
|
|
closeFires = True
|
|
|
|
|
|
|
|
def closeEvent(self, evt):
|
|
|
|
if self.closeFires:
|
|
|
|
self.onClose.emit()
|
|
|
|
evt.accept()
|
|
|
|
|
|
|
|
def closeWithoutQuitting(self):
|
|
|
|
self.closeFires = False
|
|
|
|
self.close()
|
|
|
|
self.closeFires = True
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupProfile(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
if self.pm.meta["firstRun"]:
|
2019-04-09 10:48:50 +02:00
|
|
|
# load the new deck user profile
|
|
|
|
self.pm.load(self.pm.profiles()[0])
|
2019-12-23 01:34:10 +01:00
|
|
|
self.pm.meta["firstRun"] = False
|
2019-04-09 10:48:50 +02:00
|
|
|
self.pm.save()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
self.pendingImport: Optional[str] = None
|
2017-08-16 11:45:39 +02:00
|
|
|
self.restoringBackup = False
|
2012-12-21 08:51:59 +01:00
|
|
|
# profile not provided on command line?
|
|
|
|
if not self.pm.name:
|
|
|
|
# if there's a single profile, load it automatically
|
|
|
|
profs = self.pm.profiles()
|
|
|
|
if len(profs) == 1:
|
2017-08-16 11:45:39 +02:00
|
|
|
self.pm.load(profs[0])
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.pm.name:
|
|
|
|
self.showProfileManager()
|
|
|
|
else:
|
|
|
|
self.loadProfile()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def showProfileManager(self) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
self.pm.profile = None
|
2012-12-21 08:51:59 +01:00
|
|
|
self.state = "profileManager"
|
2017-08-16 11:45:39 +02:00
|
|
|
d = self.profileDiag = self.ProfileManager()
|
|
|
|
f = self.profileForm = aqt.forms.profiles.Ui_MainWindow()
|
2012-12-21 08:51:59 +01:00
|
|
|
f.setupUi(d)
|
2016-05-31 10:51:40 +02:00
|
|
|
f.login.clicked.connect(self.onOpenProfile)
|
|
|
|
f.profiles.itemDoubleClicked.connect(self.onOpenProfile)
|
2017-08-16 11:45:39 +02:00
|
|
|
f.openBackup.clicked.connect(self.onOpenBackup)
|
|
|
|
f.quit.clicked.connect(d.close)
|
|
|
|
d.onClose.connect(self.cleanupAndExit)
|
2016-05-31 10:51:40 +02:00
|
|
|
f.add.clicked.connect(self.onAddProfile)
|
|
|
|
f.rename.clicked.connect(self.onRenameProfile)
|
|
|
|
f.delete_2.clicked.connect(self.onRemProfile)
|
|
|
|
f.profiles.currentRowChanged.connect(self.onProfileRowChange)
|
2017-08-16 11:45:39 +02:00
|
|
|
f.statusbar.setVisible(False)
|
|
|
|
# enter key opens profile
|
2019-12-23 01:34:10 +01:00
|
|
|
QShortcut(QKeySequence("Return"), d, activated=self.onOpenProfile) # type: ignore
|
2012-12-21 08:51:59 +01:00
|
|
|
self.refreshProfilesList()
|
|
|
|
# raise first, for osx testing
|
|
|
|
d.show()
|
2018-02-01 03:14:04 +01:00
|
|
|
d.activateWindow()
|
|
|
|
d.raise_()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def refreshProfilesList(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
f = self.profileForm
|
|
|
|
f.profiles.clear()
|
|
|
|
profs = self.pm.profiles()
|
|
|
|
f.profiles.addItems(profs)
|
|
|
|
try:
|
|
|
|
idx = profs.index(self.pm.name)
|
|
|
|
except:
|
|
|
|
idx = 0
|
|
|
|
f.profiles.setCurrentRow(idx)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onProfileRowChange(self, n: int) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if n < 0:
|
|
|
|
# called on .clear()
|
|
|
|
return
|
|
|
|
name = self.pm.profiles()[n]
|
|
|
|
f = self.profileForm
|
2017-08-16 11:45:39 +02:00
|
|
|
self.pm.load(name)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def openProfile(self):
|
|
|
|
name = self.pm.profiles()[self.profileForm.profiles.currentRow()]
|
2017-08-16 11:45:39 +02:00
|
|
|
return self.pm.load(name)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onOpenProfile(self) -> None:
|
2017-08-16 11:45:39 +02:00
|
|
|
self.loadProfile(self.profileDiag.closeWithoutQuitting)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def profileNameOk(self, str):
|
2013-02-20 07:12:07 +01:00
|
|
|
return not checkInvalidFilename(str)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onAddProfile(self):
|
2019-04-25 01:37:58 +02:00
|
|
|
name = getOnlyText(_("Name:")).strip()
|
2012-12-21 08:51:59 +01:00
|
|
|
if name:
|
|
|
|
if name in self.pm.profiles():
|
|
|
|
return showWarning(_("Name exists."))
|
|
|
|
if not self.profileNameOk(name):
|
|
|
|
return
|
|
|
|
self.pm.create(name)
|
|
|
|
self.pm.name = name
|
|
|
|
self.refreshProfilesList()
|
|
|
|
|
|
|
|
def onRenameProfile(self):
|
2019-04-25 01:37:58 +02:00
|
|
|
name = getOnlyText(_("New name:"), default=self.pm.name).strip()
|
2012-12-21 08:51:59 +01:00
|
|
|
if not name:
|
|
|
|
return
|
|
|
|
if name == self.pm.name:
|
|
|
|
return
|
|
|
|
if name in self.pm.profiles():
|
|
|
|
return showWarning(_("Name exists."))
|
|
|
|
if not self.profileNameOk(name):
|
|
|
|
return
|
|
|
|
self.pm.rename(name)
|
|
|
|
self.refreshProfilesList()
|
|
|
|
|
|
|
|
def onRemProfile(self):
|
|
|
|
profs = self.pm.profiles()
|
|
|
|
if len(profs) < 2:
|
|
|
|
return showWarning(_("There must be at least one profile."))
|
|
|
|
# sure?
|
2019-12-23 01:34:10 +01:00
|
|
|
if not askUser(
|
|
|
|
_(
|
|
|
|
"""\
|
2012-12-21 08:51:59 +01:00
|
|
|
All cards, notes, and media for this profile will be deleted. \
|
2019-12-23 01:34:10 +01:00
|
|
|
Are you sure?"""
|
|
|
|
),
|
|
|
|
msgfunc=QMessageBox.warning,
|
|
|
|
defaultno=True,
|
|
|
|
):
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
self.pm.remove(self.pm.name)
|
|
|
|
self.refreshProfilesList()
|
|
|
|
|
2017-08-16 11:45:39 +02:00
|
|
|
def onOpenBackup(self):
|
2019-12-23 01:34:10 +01:00
|
|
|
if not askUser(
|
|
|
|
_(
|
|
|
|
"""\
|
|
|
|
Replace your collection with an earlier backup?"""
|
|
|
|
),
|
|
|
|
msgfunc=QMessageBox.warning,
|
|
|
|
defaultno=True,
|
|
|
|
):
|
2017-08-16 11:45:39 +02:00
|
|
|
return
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2017-08-16 11:45:39 +02:00
|
|
|
def doOpen(path):
|
|
|
|
self._openBackup(path)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
|
|
|
getFile(
|
|
|
|
self.profileDiag,
|
|
|
|
_("Revert to backup"),
|
|
|
|
cb=doOpen,
|
|
|
|
filter="*.colpkg",
|
|
|
|
dir=self.pm.backupFolder(),
|
|
|
|
)
|
2017-08-16 11:45:39 +02:00
|
|
|
|
|
|
|
def _openBackup(self, path):
|
|
|
|
try:
|
|
|
|
# move the existing collection to the trash, as it may not open
|
|
|
|
self.pm.trashCollection()
|
|
|
|
except:
|
2019-12-23 01:34:10 +01:00
|
|
|
showWarning(
|
|
|
|
_(
|
|
|
|
"Unable to move existing file to trash - please try restarting your computer."
|
|
|
|
)
|
|
|
|
)
|
2017-08-16 11:45:39 +02:00
|
|
|
return
|
|
|
|
|
|
|
|
self.pendingImport = path
|
|
|
|
self.restoringBackup = True
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
showInfo(
|
|
|
|
_(
|
|
|
|
"""\
|
2017-08-16 11:45:39 +02:00
|
|
|
Automatic syncing and backups have been disabled while restoring. To enable them again, \
|
2019-12-23 01:34:10 +01:00
|
|
|
close the profile or restart Anki."""
|
|
|
|
)
|
|
|
|
)
|
2017-08-16 11:45:39 +02:00
|
|
|
|
|
|
|
self.onOpenProfile()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def loadProfile(self, onsuccess: Optional[Callable] = None) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
self.maybeAutoSync()
|
|
|
|
|
|
|
|
if not self.loadCollection():
|
|
|
|
return
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# show main window
|
2019-12-23 01:34:10 +01:00
|
|
|
if self.pm.profile["mainWindowState"]:
|
2012-12-21 08:51:59 +01:00
|
|
|
restoreGeom(self, "mainWindow")
|
|
|
|
restoreState(self, "mainWindow")
|
2013-05-22 06:04:45 +02:00
|
|
|
# titlebar
|
2018-11-12 13:23:47 +01:00
|
|
|
self.setWindowTitle(self.pm.name + " - Anki")
|
2012-12-21 08:51:59 +01:00
|
|
|
# show and raise window for osx
|
|
|
|
self.show()
|
|
|
|
self.activateWindow()
|
|
|
|
self.raise_()
|
2017-08-16 06:38:55 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# import pending?
|
|
|
|
if self.pendingImport:
|
2020-01-04 04:30:33 +01:00
|
|
|
if self._isAddon(self.pendingImport):
|
|
|
|
self.installAddon(self.pendingImport)
|
|
|
|
else:
|
|
|
|
self.handleImport(self.pendingImport)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.pendingImport = None
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.profile_did_open()
|
2017-08-16 11:45:39 +02:00
|
|
|
if onsuccess:
|
|
|
|
onsuccess()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def unloadProfile(self, onsuccess: Callable) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
def callback():
|
|
|
|
self._unloadProfile()
|
|
|
|
onsuccess()
|
|
|
|
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.profile_will_close()
|
2017-08-16 06:38:55 +02:00
|
|
|
self.unloadCollection(callback)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _unloadProfile(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
self.pm.profile["mainWindowGeom"] = self.saveGeometry()
|
|
|
|
self.pm.profile["mainWindowState"] = self.saveState()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.pm.save()
|
|
|
|
self.hide()
|
2017-08-16 06:38:55 +02:00
|
|
|
|
2017-08-16 11:45:39 +02:00
|
|
|
self.restoringBackup = False
|
|
|
|
|
2017-08-16 06:38:55 +02:00
|
|
|
# at this point there should be no windows left
|
|
|
|
self._checkForUnclosedWidgets()
|
|
|
|
|
|
|
|
self.maybeAutoSync()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _checkForUnclosedWidgets(self) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
for w in self.app.topLevelWidgets():
|
|
|
|
if w.isVisible():
|
2017-08-25 04:14:59 +02:00
|
|
|
# windows with this property are safe to close immediately
|
2017-09-08 10:42:26 +02:00
|
|
|
if getattr(w, "silentlyClose", None):
|
2017-08-25 04:14:59 +02:00
|
|
|
w.close()
|
|
|
|
else:
|
2019-04-10 04:44:01 +02:00
|
|
|
print("Window should have been closed: {}".format(w))
|
2017-08-16 06:38:55 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def unloadProfileAndExit(self) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
self.unloadProfile(self.cleanupAndExit)
|
|
|
|
|
|
|
|
def unloadProfileAndShowProfileManager(self):
|
|
|
|
self.unloadProfile(self.showProfileManager)
|
2017-08-08 04:55:30 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def cleanupAndExit(self) -> None:
|
2017-08-08 04:55:30 +02:00
|
|
|
self.errorHandler.unload()
|
|
|
|
self.mediaServer.shutdown()
|
2020-01-02 10:43:19 +01:00
|
|
|
aqt.sound.cleanupMPV()
|
2017-08-08 04:55:30 +02:00
|
|
|
self.app.exit(0)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2017-10-05 05:48:24 +02:00
|
|
|
# Sound/video
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupSound(self) -> None:
|
2018-05-10 06:50:23 +02:00
|
|
|
if isWin:
|
|
|
|
return
|
2017-10-05 05:48:24 +02:00
|
|
|
try:
|
2020-01-02 10:43:19 +01:00
|
|
|
aqt.sound.setupMPV()
|
2017-10-05 05:48:24 +02:00
|
|
|
except FileNotFoundError:
|
2017-10-05 09:24:55 +02:00
|
|
|
print("mpv not found, reverting to mplayer")
|
2020-01-02 10:43:19 +01:00
|
|
|
except aqt.mpv.MPVProcessError:
|
2017-10-05 09:24:55 +02:00
|
|
|
print("mpv too old, reverting to mplayer")
|
2017-10-05 05:48:24 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Collection load/unload
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def loadCollection(self) -> bool:
|
2012-12-21 08:51:59 +01:00
|
|
|
try:
|
2018-02-05 03:15:57 +01:00
|
|
|
return self._loadCollection()
|
2017-08-16 06:38:55 +02:00
|
|
|
except Exception as e:
|
2019-12-23 01:34:10 +01:00
|
|
|
showWarning(
|
|
|
|
_(
|
|
|
|
"""\
|
2017-08-16 06:38:55 +02:00
|
|
|
Anki was unable to open your collection file. If problems persist after \
|
2017-08-16 11:45:39 +02:00
|
|
|
restarting your computer, please use the Open Backup button in the profile \
|
|
|
|
manager.
|
2014-06-26 21:25:40 +02:00
|
|
|
|
|
|
|
Debug info:
|
2019-12-23 01:34:10 +01:00
|
|
|
"""
|
|
|
|
)
|
|
|
|
+ traceback.format_exc()
|
|
|
|
)
|
2018-02-05 03:15:57 +01:00
|
|
|
# clean up open collection if possible
|
|
|
|
if self.col:
|
|
|
|
try:
|
|
|
|
self.col.close(save=False)
|
|
|
|
except:
|
|
|
|
pass
|
|
|
|
self.col = None
|
|
|
|
|
|
|
|
# return to profile manager
|
possible fix for " super-class ... Preferences was never called"
Can't reproduce the issue, but it seems the user was able to open the
preferences screen when no collection was loaded. If an error was
caught in loadCollection() the main window was not being hidden, so
perhaps a timing issue was preventing the profiles screen from taking
modal focus.
Removed the check in the prefs init - it is hopefully no longer
necessary, and returning before QDialog.__init__() was called was
causing the problem.
Caught exception:
File "aqt/webview.py", line 27, in cmd
File "aqt/webview.py", line 85, in _onCmd
File "aqt/webview.py", line 360, in _onBridgeCmd
File "aqt/toolbar.py", line 56, in _linkHandler
File "aqt/toolbar.py", line 80, in _syncLinkHandler
File "aqt/main.py", line 669, in onSync
File "aqt/main.py", line 365, in unloadCollection
File "aqt/main.py", line 611, in closeAllWindows
File "aqt/__init__.py", line 110, in closeAll
<class 'RuntimeError'>: super-class __init__() of type Preferences was never called
2019-04-21 11:02:03 +02:00
|
|
|
self.hide()
|
2017-08-16 06:38:55 +02:00
|
|
|
self.showProfileManager()
|
|
|
|
return False
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _loadCollection(self) -> bool:
|
2018-02-05 03:15:57 +01:00
|
|
|
cpath = self.pm.collectionPath()
|
|
|
|
|
|
|
|
self.col = Collection(cpath, log=True)
|
|
|
|
|
2017-11-01 03:38:43 +01:00
|
|
|
self.setEnabled(True)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.progress.setupDB(self.col.db)
|
2012-12-21 12:55:57 +01:00
|
|
|
self.maybeEnableUndo()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.moveToState("deckBrowser")
|
2017-08-16 06:38:55 +02:00
|
|
|
return True
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def unloadCollection(self, onsuccess: Callable) -> None:
|
2017-08-16 06:38:55 +02:00
|
|
|
def callback():
|
2017-11-01 03:38:43 +01:00
|
|
|
self.setEnabled(False)
|
2017-08-16 06:38:55 +02:00
|
|
|
self._unloadCollection()
|
|
|
|
onsuccess()
|
2013-04-23 15:37:21 +02:00
|
|
|
|
2017-08-16 06:38:55 +02:00
|
|
|
self.closeAllWindows(callback)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _unloadCollection(self) -> None:
|
2017-08-16 11:45:39 +02:00
|
|
|
if not self.col:
|
|
|
|
return
|
|
|
|
if self.restoringBackup:
|
|
|
|
label = _("Closing...")
|
|
|
|
else:
|
|
|
|
label = _("Backing Up...")
|
|
|
|
self.progress.start(label=label, immediate=True)
|
2017-08-16 06:38:55 +02:00
|
|
|
corrupt = False
|
|
|
|
try:
|
|
|
|
self.maybeOptimize()
|
|
|
|
if not devMode:
|
|
|
|
corrupt = self.col.db.scalar("pragma integrity_check") != "ok"
|
|
|
|
except:
|
|
|
|
corrupt = True
|
|
|
|
try:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.col.close()
|
2017-08-16 13:06:50 +02:00
|
|
|
except:
|
|
|
|
corrupt = True
|
2017-08-16 11:45:39 +02:00
|
|
|
finally:
|
|
|
|
self.col = None
|
2017-08-16 13:06:50 +02:00
|
|
|
if corrupt:
|
2019-12-23 01:34:10 +01:00
|
|
|
showWarning(
|
|
|
|
_(
|
|
|
|
"Your collection file appears to be corrupt. \
|
2017-08-16 13:06:50 +02:00
|
|
|
This can happen when the file is copied or moved while Anki is open, or \
|
|
|
|
when the collection is stored on a network or cloud drive. If problems \
|
|
|
|
persist after restarting your computer, please open an automatic backup \
|
2019-12-23 01:34:10 +01:00
|
|
|
from the profile screen."
|
|
|
|
)
|
|
|
|
)
|
2017-08-16 11:45:39 +02:00
|
|
|
if not corrupt and not self.restoringBackup:
|
2017-08-16 06:38:55 +02:00
|
|
|
self.backup()
|
2017-08-16 11:45:39 +02:00
|
|
|
|
2017-08-16 06:38:55 +02:00
|
|
|
self.progress.finish()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Backup and auto-optimize
|
|
|
|
##########################################################################
|
|
|
|
|
2017-01-08 10:29:57 +01:00
|
|
|
class BackupThread(Thread):
|
|
|
|
def __init__(self, path, data):
|
|
|
|
Thread.__init__(self)
|
|
|
|
self.path = path
|
|
|
|
self.data = data
|
|
|
|
# create the file in calling thread to ensure the same
|
|
|
|
# file is not created twice
|
|
|
|
open(self.path, "wb").close()
|
|
|
|
|
|
|
|
def run(self):
|
|
|
|
z = zipfile.ZipFile(self.path, "w", zipfile.ZIP_DEFLATED)
|
|
|
|
z.writestr("collection.anki2", self.data)
|
|
|
|
z.writestr("media", "{}")
|
|
|
|
z.close()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def backup(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
nbacks = self.pm.profile["numBackups"]
|
2017-08-01 06:28:13 +02:00
|
|
|
if not nbacks or devMode:
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
dir = self.pm.backupFolder()
|
|
|
|
path = self.pm.collectionPath()
|
2017-08-14 10:53:39 +02:00
|
|
|
|
|
|
|
# do backup
|
2019-12-23 01:34:10 +01:00
|
|
|
fname = time.strftime(
|
|
|
|
"backup-%Y-%m-%d-%H.%M.%S.colpkg", time.localtime(time.time())
|
|
|
|
)
|
2017-08-14 10:53:39 +02:00
|
|
|
newpath = os.path.join(dir, fname)
|
2017-12-11 08:25:51 +01:00
|
|
|
with open(path, "rb") as f:
|
|
|
|
data = f.read()
|
2017-08-14 10:53:39 +02:00
|
|
|
b = self.BackupThread(newpath, data)
|
|
|
|
b.start()
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# find existing backups
|
|
|
|
backups = []
|
|
|
|
for file in os.listdir(dir):
|
2017-08-14 10:53:39 +02:00
|
|
|
# only look for new-style format
|
2017-12-11 08:25:51 +01:00
|
|
|
m = re.match(r"backup-\d{4}-\d{2}-.+.colpkg", file)
|
2012-12-21 08:51:59 +01:00
|
|
|
if not m:
|
|
|
|
continue
|
2017-08-14 10:53:39 +02:00
|
|
|
backups.append(file)
|
2012-12-21 08:51:59 +01:00
|
|
|
backups.sort()
|
2017-08-14 10:53:39 +02:00
|
|
|
|
|
|
|
# remove old ones
|
|
|
|
while len(backups) > nbacks:
|
|
|
|
fname = backups.pop(0)
|
|
|
|
path = os.path.join(dir, fname)
|
2017-10-05 06:39:47 +02:00
|
|
|
os.unlink(path)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def maybeOptimize(self) -> None:
|
2013-05-07 08:17:46 +02:00
|
|
|
# have two weeks passed?
|
2019-12-23 01:34:10 +01:00
|
|
|
if (intTime() - self.pm.profile["lastOptimize"]) < 86400 * 14:
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
self.progress.start(label=_("Optimizing..."), immediate=True)
|
|
|
|
self.col.optimize()
|
2019-12-23 01:34:10 +01:00
|
|
|
self.pm.profile["lastOptimize"] = intTime()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.pm.save()
|
|
|
|
self.progress.finish()
|
|
|
|
|
|
|
|
# State machine
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def moveToState(self, state: str, *args) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
# print("-> move from", self.state, "to", state)
|
2012-12-21 08:51:59 +01:00
|
|
|
oldState = self.state or "dummy"
|
2019-12-23 01:34:10 +01:00
|
|
|
cleanup = getattr(self, "_" + oldState + "Cleanup", None)
|
2012-12-21 08:51:59 +01:00
|
|
|
if cleanup:
|
2019-03-04 02:22:40 +01:00
|
|
|
# pylint: disable=not-callable
|
2012-12-21 08:51:59 +01:00
|
|
|
cleanup(state)
|
2017-06-22 08:36:54 +02:00
|
|
|
self.clearStateShortcuts()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.state = state
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_will_change(state, oldState)
|
2019-12-23 01:34:10 +01:00
|
|
|
getattr(self, "_" + state + "State")(oldState, *args)
|
2017-01-17 05:05:05 +01:00
|
|
|
if state != "resetRequired":
|
|
|
|
self.bottomWeb.show()
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_did_change(state, oldState)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _deckBrowserState(self, oldState: str) -> None:
|
2020-01-19 02:31:09 +01:00
|
|
|
self.maybe_check_for_addon_updates()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.deckBrowser.show()
|
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def _colLoadingState(self, oldState) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
"Run once, when col is loaded."
|
|
|
|
self.enableColMenuItems()
|
|
|
|
# ensure cwd is set if media dir exists
|
|
|
|
self.col.media.dir()
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.collection_did_load(self.col)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.moveToState("overview")
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _selectedDeck(self) -> Optional[Dict[str, Any]]:
|
2012-12-21 08:51:59 +01:00
|
|
|
did = self.col.decks.selected()
|
|
|
|
if not self.col.decks.nameOrNone(did):
|
|
|
|
showInfo(_("Please select a deck."))
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.col.decks.get(did)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def _overviewState(self, oldState: str) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self._selectedDeck():
|
|
|
|
return self.moveToState("deckBrowser")
|
|
|
|
self.col.reset()
|
|
|
|
self.overview.show()
|
|
|
|
|
|
|
|
def _reviewState(self, oldState):
|
|
|
|
self.reviewer.show()
|
|
|
|
|
|
|
|
def _reviewCleanup(self, newState):
|
|
|
|
if newState != "resetRequired" and newState != "review":
|
|
|
|
self.reviewer.cleanup()
|
|
|
|
|
|
|
|
# Resetting state
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def reset(self, guiOnly: bool = False) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
"Called for non-trivial edits. Rebuilds queue and updates UI."
|
|
|
|
if self.col:
|
|
|
|
if not guiOnly:
|
|
|
|
self.col.reset()
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_did_reset()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.maybeEnableUndo()
|
|
|
|
self.moveToState(self.state)
|
|
|
|
|
|
|
|
def requireReset(self, modal=False):
|
|
|
|
"Signal queue needs to be rebuilt when edits are finished or by user."
|
|
|
|
self.autosave()
|
|
|
|
self.resetModal = modal
|
|
|
|
if self.interactiveState():
|
|
|
|
self.moveToState("resetRequired")
|
|
|
|
|
|
|
|
def interactiveState(self):
|
|
|
|
"True if not in profile manager, syncing, etc."
|
|
|
|
return self.state in ("overview", "review", "deckBrowser")
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def maybeReset(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.autosave()
|
|
|
|
if self.state == "resetRequired":
|
|
|
|
self.state = self.returnState
|
|
|
|
self.reset()
|
|
|
|
|
|
|
|
def delayedMaybeReset(self):
|
|
|
|
# if we redraw the page in a button click event it will often crash on
|
|
|
|
# windows
|
|
|
|
self.progress.timer(100, self.maybeReset, False)
|
|
|
|
|
|
|
|
def _resetRequiredState(self, oldState):
|
|
|
|
if oldState != "resetRequired":
|
|
|
|
self.returnState = oldState
|
|
|
|
if self.resetModal:
|
|
|
|
# we don't have to change the webview, as we have a covering window
|
|
|
|
return
|
2016-05-31 10:51:40 +02:00
|
|
|
self.web.resetHandlers()
|
2016-06-06 07:50:03 +02:00
|
|
|
self.web.onBridgeCmd = lambda url: self.delayedMaybeReset()
|
2012-12-21 08:51:59 +01:00
|
|
|
i = _("Waiting for editing to finish.")
|
|
|
|
b = self.button("refresh", _("Resume Now"), id="resume")
|
2019-12-23 01:34:10 +01:00
|
|
|
self.web.stdHtml(
|
|
|
|
"""
|
2012-12-21 08:51:59 +01:00
|
|
|
<center><div style="height: 100%%">
|
|
|
|
<div style="position:relative; vertical-align: middle;">
|
2018-05-01 05:35:28 +02:00
|
|
|
%s<br><br>
|
2012-12-21 08:51:59 +01:00
|
|
|
%s</div></div></center>
|
2017-08-01 05:57:15 +02:00
|
|
|
<script>$('#resume').focus()</script>
|
2019-12-23 01:34:10 +01:00
|
|
|
"""
|
|
|
|
% (i, b)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.bottomWeb.hide()
|
|
|
|
self.web.setFocus()
|
|
|
|
|
|
|
|
# HTML helpers
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
def button(
|
|
|
|
self,
|
|
|
|
link: str,
|
|
|
|
name: str,
|
|
|
|
key: Optional[str] = None,
|
|
|
|
class_: str = "",
|
|
|
|
id: str = "",
|
|
|
|
extra: str = "",
|
|
|
|
) -> str:
|
|
|
|
class_ = "but " + class_
|
2012-12-21 08:51:59 +01:00
|
|
|
if key:
|
|
|
|
key = _("Shortcut key: %s") % key
|
|
|
|
else:
|
|
|
|
key = ""
|
2019-12-23 01:34:10 +01:00
|
|
|
return """
|
2016-06-06 07:50:03 +02:00
|
|
|
<button id="%s" class="%s" onclick="pycmd('%s');return false;"
|
2019-12-23 01:34:10 +01:00
|
|
|
title="%s" %s>%s</button>""" % (
|
|
|
|
id,
|
|
|
|
class_,
|
|
|
|
link,
|
|
|
|
key,
|
|
|
|
extra,
|
|
|
|
name,
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Main window setup
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupMainWindow(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
# main window
|
|
|
|
self.form = aqt.forms.main.Ui_MainWindow()
|
|
|
|
self.form.setupUi(self)
|
|
|
|
# toolbar
|
2017-04-21 19:21:05 +02:00
|
|
|
tweb = self.toolbarWeb = aqt.webview.AnkiWebView()
|
2016-07-07 09:23:13 +02:00
|
|
|
tweb.title = "top toolbar"
|
2012-12-21 08:51:59 +01:00
|
|
|
tweb.setFocusPolicy(Qt.WheelFocus)
|
|
|
|
self.toolbar = aqt.toolbar.Toolbar(self, tweb)
|
|
|
|
self.toolbar.draw()
|
|
|
|
# main area
|
2014-09-15 08:04:14 +02:00
|
|
|
self.web = aqt.webview.AnkiWebView()
|
2016-07-07 09:23:13 +02:00
|
|
|
self.web.title = "main webview"
|
2012-12-21 08:51:59 +01:00
|
|
|
self.web.setFocusPolicy(Qt.WheelFocus)
|
|
|
|
self.web.setMinimumWidth(400)
|
|
|
|
# bottom area
|
|
|
|
sweb = self.bottomWeb = aqt.webview.AnkiWebView()
|
2016-07-07 09:23:13 +02:00
|
|
|
sweb.title = "bottom toolbar"
|
2012-12-21 08:51:59 +01:00
|
|
|
sweb.setFocusPolicy(Qt.WheelFocus)
|
|
|
|
# add in a layout
|
|
|
|
self.mainLayout = QVBoxLayout()
|
2019-12-23 01:34:10 +01:00
|
|
|
self.mainLayout.setContentsMargins(0, 0, 0, 0)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.mainLayout.setSpacing(0)
|
|
|
|
self.mainLayout.addWidget(tweb)
|
|
|
|
self.mainLayout.addWidget(self.web)
|
|
|
|
self.mainLayout.addWidget(sweb)
|
|
|
|
self.form.centralwidget.setLayout(self.mainLayout)
|
|
|
|
|
2019-04-09 10:48:50 +02:00
|
|
|
# force webengine processes to load before cwd is changed
|
|
|
|
if isWin:
|
2019-04-10 09:31:55 +02:00
|
|
|
for o in self.web, self.bottomWeb:
|
2019-04-16 05:24:38 +02:00
|
|
|
o.requiresCol = False
|
|
|
|
o._domReady = False
|
|
|
|
o._page.setContent(bytes("", "ascii"))
|
2019-04-09 10:48:50 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def closeAllWindows(self, onsuccess: Callable) -> None:
|
2017-08-16 11:45:39 +02:00
|
|
|
aqt.dialogs.closeAll(onsuccess)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Components
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupSignals(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
signal.signal(signal.SIGINT, self.onSigInt)
|
|
|
|
|
|
|
|
def onSigInt(self, signum, frame):
|
|
|
|
# interrupt any current transaction and schedule a rollback & quit
|
2017-08-16 11:45:39 +02:00
|
|
|
if self.col:
|
|
|
|
self.col.db.interrupt()
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
def quit():
|
|
|
|
self.col.db.rollback()
|
|
|
|
self.close()
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.progress.timer(100, quit, False)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupProgress(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.progress = aqt.progress.ProgressManager(self)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupErrorHandler(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
import aqt.errors
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.errorHandler = aqt.errors.ErrorHandler(self)
|
|
|
|
|
2020-01-04 04:34:16 +01:00
|
|
|
def setupAddons(self, args: Optional[List]) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
import aqt.addons
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.addonManager = aqt.addons.AddonManager(self)
|
2020-01-04 04:34:16 +01:00
|
|
|
|
|
|
|
if args and args[0] and self._isAddon(args[0]):
|
|
|
|
self.installAddon(args[0], startup=True)
|
|
|
|
|
2017-08-28 12:51:43 +02:00
|
|
|
if not self.safeMode:
|
|
|
|
self.addonManager.loadAddons()
|
2020-01-19 02:31:09 +01:00
|
|
|
self.maybe_check_for_addon_updates()
|
|
|
|
|
|
|
|
def maybe_check_for_addon_updates(self):
|
|
|
|
last_check = self.pm.last_addon_update_check()
|
|
|
|
elap = intTime() - last_check
|
|
|
|
|
|
|
|
if elap > 86_400:
|
|
|
|
check_and_prompt_for_updates(
|
|
|
|
self, self.addonManager, self.on_updates_installed
|
|
|
|
)
|
|
|
|
self.pm.set_last_addon_update_check(intTime())
|
|
|
|
|
|
|
|
def on_updates_installed(self, log: List[DownloadLogEntry]) -> None:
|
|
|
|
if log:
|
|
|
|
show_log_to_user(self, log)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupSpellCheck(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
os.environ["QTWEBENGINE_DICTIONARIES_PATH"] = os.path.join(
|
|
|
|
self.pm.base, "dictionaries"
|
|
|
|
)
|
2019-03-06 14:18:26 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupThreads(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self._mainThread = QThread.currentThread()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def inMainThread(self) -> bool:
|
2012-12-21 08:51:59 +01:00
|
|
|
return self._mainThread == QThread.currentThread()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupDeckBrowser(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
from aqt.deckbrowser import DeckBrowser
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.deckBrowser = DeckBrowser(self)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupOverview(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
from aqt.overview import Overview
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.overview = Overview(self)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupReviewer(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
from aqt.reviewer import Reviewer
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.reviewer = Reviewer(self)
|
|
|
|
|
|
|
|
# Syncing
|
|
|
|
##########################################################################
|
|
|
|
|
2017-08-16 06:38:55 +02:00
|
|
|
# expects a current profile and a loaded collection; reloads
|
|
|
|
# collection after sync completes
|
|
|
|
def onSync(self):
|
|
|
|
self.unloadCollection(self._onSync)
|
|
|
|
|
|
|
|
def _onSync(self):
|
|
|
|
self._sync()
|
|
|
|
if not self.loadCollection():
|
|
|
|
return
|
|
|
|
|
|
|
|
# expects a current profile, but no collection loaded
|
2019-12-20 09:43:52 +01:00
|
|
|
def maybeAutoSync(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
if (
|
|
|
|
not self.pm.profile["syncKey"]
|
|
|
|
or not self.pm.profile["autoSync"]
|
2017-08-16 11:45:39 +02:00
|
|
|
or self.safeMode
|
2019-12-23 01:34:10 +01:00
|
|
|
or self.restoringBackup
|
|
|
|
):
|
2017-08-16 06:38:55 +02:00
|
|
|
return
|
|
|
|
|
|
|
|
# ok to sync
|
|
|
|
self._sync()
|
|
|
|
|
|
|
|
def _sync(self):
|
|
|
|
from aqt.sync import SyncManager
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2017-08-16 06:38:55 +02:00
|
|
|
self.state = "sync"
|
|
|
|
self.syncer = SyncManager(self, self.pm)
|
|
|
|
self.syncer.sync()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Tools
|
|
|
|
##########################################################################
|
|
|
|
|
|
|
|
def raiseMain(self):
|
|
|
|
if not self.app.activeWindow():
|
|
|
|
# make sure window is shown
|
|
|
|
self.setWindowState(self.windowState() & ~Qt.WindowMinimized)
|
|
|
|
return True
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupStyle(self) -> None:
|
2018-12-14 11:35:12 +01:00
|
|
|
buf = ""
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
if isWin and platform.release() == "10":
|
2018-12-14 11:35:12 +01:00
|
|
|
# add missing bottom border to menubar
|
|
|
|
buf += """
|
|
|
|
QMenuBar {
|
|
|
|
border-bottom: 1px solid #aaa;
|
|
|
|
background: white;
|
|
|
|
}
|
|
|
|
"""
|
|
|
|
# qt bug? setting the above changes the browser sidebar
|
|
|
|
# to white as well, so set it back
|
|
|
|
buf += """
|
|
|
|
QTreeWidget {
|
|
|
|
background: #eee;
|
|
|
|
}
|
|
|
|
"""
|
|
|
|
|
|
|
|
# allow addons to modify the styling
|
2020-01-15 08:18:11 +01:00
|
|
|
buf = gui_hooks.style_did_init(buf)
|
2018-12-14 11:35:12 +01:00
|
|
|
|
|
|
|
# allow users to extend styling
|
|
|
|
p = os.path.join(aqt.mw.pm.base, "style.css")
|
|
|
|
if os.path.exists(p):
|
|
|
|
buf += open(p).read()
|
|
|
|
|
|
|
|
self.app.setStyleSheet(buf)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Key handling
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupKeys(self) -> None:
|
2017-06-22 08:36:54 +02:00
|
|
|
globalShortcuts = [
|
2018-03-18 15:50:50 +01:00
|
|
|
("Ctrl+:", self.onDebug),
|
2017-06-22 08:36:54 +02:00
|
|
|
("d", lambda: self.moveToState("deckBrowser")),
|
|
|
|
("s", self.onStudyKey),
|
|
|
|
("a", self.onAddCard),
|
|
|
|
("b", self.onBrowse),
|
2018-05-31 05:05:30 +02:00
|
|
|
("t", self.onStats),
|
2019-12-23 01:34:10 +01:00
|
|
|
("y", self.onSync),
|
2017-06-22 08:36:54 +02:00
|
|
|
]
|
|
|
|
self.applyShortcuts(globalShortcuts)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
self.stateShortcuts: Sequence[Tuple[str, Callable]] = []
|
2017-06-22 08:36:54 +02:00
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
def applyShortcuts(
|
|
|
|
self, shortcuts: Sequence[Tuple[str, Callable]]
|
|
|
|
) -> List[QShortcut]:
|
2017-06-22 08:36:54 +02:00
|
|
|
qshortcuts = []
|
|
|
|
for key, fn in shortcuts:
|
2019-12-23 01:34:10 +01:00
|
|
|
scut = QShortcut(QKeySequence(key), self, activated=fn) # type: ignore
|
2018-08-29 02:07:33 +02:00
|
|
|
scut.setAutoRepeat(False)
|
|
|
|
qshortcuts.append(scut)
|
2017-06-22 08:36:54 +02:00
|
|
|
return qshortcuts
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setStateShortcuts(self, shortcuts: List[Tuple[str, Callable]]) -> None:
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_shortcuts_will_change(self.state, shortcuts)
|
2020-01-15 03:46:53 +01:00
|
|
|
# legacy hook
|
2019-12-23 01:34:10 +01:00
|
|
|
runHook(self.state + "StateShortcuts", shortcuts)
|
2017-06-22 08:36:54 +02:00
|
|
|
self.stateShortcuts = self.applyShortcuts(shortcuts)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def clearStateShortcuts(self) -> None:
|
2017-06-22 08:36:54 +02:00
|
|
|
for qs in self.stateShortcuts:
|
|
|
|
sip.delete(qs)
|
|
|
|
self.stateShortcuts = []
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onStudyKey(self) -> None:
|
2017-06-22 08:36:54 +02:00
|
|
|
if self.state == "overview":
|
|
|
|
self.col.startTimebox()
|
|
|
|
self.moveToState("review")
|
2017-06-06 07:56:21 +02:00
|
|
|
else:
|
2017-06-22 08:36:54 +02:00
|
|
|
self.moveToState("overview")
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# App exit
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def closeEvent(self, event: QCloseEvent) -> None:
|
2017-08-16 11:45:39 +02:00
|
|
|
if self.state == "profileManager":
|
|
|
|
# if profile manager active, this event may fire via OS X menu bar's
|
|
|
|
# quit option
|
|
|
|
self.profileDiag.close()
|
|
|
|
event.accept()
|
|
|
|
else:
|
|
|
|
# ignore the event for now, as we need time to clean up
|
|
|
|
event.ignore()
|
|
|
|
self.unloadProfileAndExit()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Undo & autosave
|
|
|
|
##########################################################################
|
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def onUndo(self) -> None:
|
2012-12-21 23:42:52 +01:00
|
|
|
n = self.col.undoName()
|
2017-01-08 11:47:26 +01:00
|
|
|
if not n:
|
|
|
|
return
|
2012-12-21 08:51:59 +01:00
|
|
|
cid = self.col.undo()
|
|
|
|
if cid and self.state == "review":
|
|
|
|
card = self.col.getCard(cid)
|
2019-04-08 07:47:49 +02:00
|
|
|
self.col.sched.reset()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.reviewer.cardQueue.append(card)
|
2019-01-29 00:35:46 +01:00
|
|
|
self.reviewer.nextCard()
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.review_did_undo(cid)
|
2019-05-18 02:17:36 +02:00
|
|
|
else:
|
|
|
|
self.reset()
|
|
|
|
tooltip(_("Reverted to state prior to '%s'.") % n.lower())
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_did_revert(n)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.maybeEnableUndo()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def maybeEnableUndo(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if self.col and self.col.undoName():
|
2019-12-23 01:34:10 +01:00
|
|
|
self.form.actionUndo.setText(_("Undo %s") % self.col.undoName())
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.actionUndo.setEnabled(True)
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.undo_state_did_change(True)
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
|
|
|
self.form.actionUndo.setText(_("Undo"))
|
|
|
|
self.form.actionUndo.setEnabled(False)
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.undo_state_did_change(False)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def checkpoint(self, name):
|
|
|
|
self.col.save(name)
|
|
|
|
self.maybeEnableUndo()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def autosave(self) -> None:
|
2017-01-13 07:20:39 +01:00
|
|
|
saved = self.col.autosave()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.maybeEnableUndo()
|
2017-01-13 07:20:39 +01:00
|
|
|
if saved:
|
|
|
|
self.doGC()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Other menu operations
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onAddCard(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.dialogs.open("AddCards", self)
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onBrowse(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.dialogs.open("Browser", self)
|
|
|
|
|
|
|
|
def onEditCurrent(self):
|
|
|
|
aqt.dialogs.open("EditCurrent", self)
|
|
|
|
|
|
|
|
def onDeckConf(self, deck=None):
|
|
|
|
if not deck:
|
|
|
|
deck = self.col.decks.current()
|
2019-12-23 01:34:10 +01:00
|
|
|
if deck["dyn"]:
|
2012-12-21 08:51:59 +01:00
|
|
|
import aqt.dyndeckconf
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.dyndeckconf.DeckConf(self, deck=deck)
|
|
|
|
else:
|
|
|
|
import aqt.deckconf
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.deckconf.DeckConf(self, deck)
|
|
|
|
|
|
|
|
def onOverview(self):
|
|
|
|
self.col.reset()
|
|
|
|
self.moveToState("overview")
|
|
|
|
|
|
|
|
def onStats(self):
|
|
|
|
deck = self._selectedDeck()
|
|
|
|
if not deck:
|
|
|
|
return
|
2017-06-22 08:49:53 +02:00
|
|
|
aqt.dialogs.open("DeckStats", self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onPrefs(self):
|
2017-09-10 07:15:12 +02:00
|
|
|
aqt.dialogs.open("Preferences", self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2012-12-22 00:21:24 +01:00
|
|
|
def onNoteTypes(self):
|
|
|
|
import aqt.models
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-22 00:21:24 +01:00
|
|
|
aqt.models.Models(self, self, fromMain=True)
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
def onAbout(self):
|
2017-06-26 05:05:11 +02:00
|
|
|
aqt.dialogs.open("About", self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onDonate(self):
|
|
|
|
openLink(aqt.appDonate)
|
|
|
|
|
|
|
|
def onDocumentation(self):
|
|
|
|
openHelp("")
|
|
|
|
|
|
|
|
# Importing & exporting
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def handleImport(self, path: str) -> None:
|
2013-06-30 00:08:37 +02:00
|
|
|
import aqt.importing
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2013-06-30 00:08:37 +02:00
|
|
|
if not os.path.exists(path):
|
2019-12-20 09:43:52 +01:00
|
|
|
showInfo(_("Please use File>Import to import this file."))
|
|
|
|
return None
|
2013-06-30 00:08:37 +02:00
|
|
|
|
|
|
|
aqt.importing.importFile(self, path)
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2013-06-30 00:08:37 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
def onImport(self):
|
|
|
|
import aqt.importing
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.importing.onImport(self)
|
|
|
|
|
2014-06-20 02:13:12 +02:00
|
|
|
def onExport(self, did=None):
|
2012-12-21 08:51:59 +01:00
|
|
|
import aqt.exporting
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2014-06-20 02:13:12 +02:00
|
|
|
aqt.exporting.ExportDialog(self, did=did)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-01-03 17:57:33 +01:00
|
|
|
# Installing add-ons from CLI / mimetype handler
|
|
|
|
##########################################################################
|
|
|
|
|
2020-01-04 04:34:16 +01:00
|
|
|
def installAddon(self, path: str, startup: bool = False):
|
2020-01-03 17:57:33 +01:00
|
|
|
from aqt.addons import installAddonPackages
|
2020-01-03 18:23:28 +01:00
|
|
|
|
2020-01-04 04:34:16 +01:00
|
|
|
installAddonPackages(
|
2020-01-04 04:45:43 +01:00
|
|
|
self.addonManager,
|
|
|
|
[path],
|
|
|
|
warn=True,
|
|
|
|
advise_restart=not startup,
|
|
|
|
strictly_modal=startup,
|
|
|
|
parent=None if startup else self,
|
2020-01-04 04:34:16 +01:00
|
|
|
)
|
2020-01-03 17:57:33 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Cramming
|
|
|
|
##########################################################################
|
|
|
|
|
|
|
|
def onCram(self, search=""):
|
|
|
|
import aqt.dyndeckconf
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
n = 1
|
2013-01-30 10:27:34 +01:00
|
|
|
deck = self.col.decks.current()
|
2012-12-21 08:51:59 +01:00
|
|
|
if not search:
|
2019-12-23 01:34:10 +01:00
|
|
|
if not deck["dyn"]:
|
|
|
|
search = 'deck:"%s" ' % deck["name"]
|
2012-12-21 08:51:59 +01:00
|
|
|
decks = self.col.decks.allNames()
|
|
|
|
while _("Filtered Deck %d") % n in decks:
|
|
|
|
n += 1
|
|
|
|
name = _("Filtered Deck %d") % n
|
|
|
|
did = self.col.decks.newDyn(name)
|
|
|
|
diag = aqt.dyndeckconf.DeckConf(self, first=True, search=search)
|
|
|
|
if not diag.ok:
|
|
|
|
# user cancelled first config
|
|
|
|
self.col.decks.rem(did)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.col.decks.select(deck["id"])
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Menu, title bar & status
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupMenus(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
m = self.form
|
2019-12-23 01:34:10 +01:00
|
|
|
m.actionSwitchProfile.triggered.connect(self.unloadProfileAndShowProfileManager)
|
2016-05-31 10:51:40 +02:00
|
|
|
m.actionImport.triggered.connect(self.onImport)
|
|
|
|
m.actionExport.triggered.connect(self.onExport)
|
|
|
|
m.actionExit.triggered.connect(self.close)
|
|
|
|
m.actionPreferences.triggered.connect(self.onPrefs)
|
|
|
|
m.actionAbout.triggered.connect(self.onAbout)
|
|
|
|
m.actionUndo.triggered.connect(self.onUndo)
|
2018-10-23 10:40:16 +02:00
|
|
|
if qtminor < 11:
|
|
|
|
m.actionUndo.setShortcut(QKeySequence(_("Ctrl+Alt+Z")))
|
2016-05-31 10:51:40 +02:00
|
|
|
m.actionFullDatabaseCheck.triggered.connect(self.onCheckDB)
|
|
|
|
m.actionCheckMediaDatabase.triggered.connect(self.onCheckMediaDB)
|
|
|
|
m.actionDocumentation.triggered.connect(self.onDocumentation)
|
|
|
|
m.actionDonate.triggered.connect(self.onDonate)
|
|
|
|
m.actionStudyDeck.triggered.connect(self.onStudyDeck)
|
|
|
|
m.actionCreateFiltered.triggered.connect(self.onCram)
|
|
|
|
m.actionEmptyCards.triggered.connect(self.onEmptyCards)
|
|
|
|
m.actionNoteTypes.triggered.connect(self.onNoteTypes)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def updateTitleBar(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setWindowTitle("Anki")
|
|
|
|
|
|
|
|
# Auto update
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupAutoUpdate(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
import aqt.update
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.autoUpdate = aqt.update.LatestVersionFinder(self)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.autoUpdate.newVerAvail.connect(self.newVerAvail) # type: ignore
|
|
|
|
self.autoUpdate.newMsg.connect(self.newMsg) # type: ignore
|
|
|
|
self.autoUpdate.clockIsOff.connect(self.clockIsOff) # type: ignore
|
2012-12-21 08:51:59 +01:00
|
|
|
self.autoUpdate.start()
|
|
|
|
|
|
|
|
def newVerAvail(self, ver):
|
2019-12-23 01:34:10 +01:00
|
|
|
if self.pm.meta.get("suppressUpdate", None) != ver:
|
2012-12-21 08:51:59 +01:00
|
|
|
aqt.update.askAndUpdate(self, ver)
|
|
|
|
|
|
|
|
def newMsg(self, data):
|
|
|
|
aqt.update.showMessages(self, data)
|
|
|
|
|
2013-10-20 03:26:11 +02:00
|
|
|
def clockIsOff(self, diff):
|
2013-12-06 05:27:13 +01:00
|
|
|
diffText = ngettext("%s second", "%s seconds", diff) % diff
|
2019-12-23 01:34:10 +01:00
|
|
|
warn = (
|
|
|
|
_(
|
|
|
|
"""\
|
2013-12-09 07:45:39 +01:00
|
|
|
In order to ensure your collection works correctly when moved between \
|
2013-10-20 03:26:11 +02:00
|
|
|
devices, Anki requires your computer's internal clock to be set correctly. \
|
|
|
|
The internal clock can be wrong even if your system is showing the correct \
|
|
|
|
local time.
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2013-10-20 03:26:11 +02:00
|
|
|
Please go to the time settings on your computer and check the following:
|
|
|
|
|
|
|
|
- AM/PM
|
|
|
|
- Clock drift
|
|
|
|
- Day, month and year
|
|
|
|
- Timezone
|
|
|
|
- Daylight savings
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
Difference to correct time: %s."""
|
|
|
|
)
|
|
|
|
% diffText
|
|
|
|
)
|
2013-10-20 03:26:11 +02:00
|
|
|
showWarning(warn)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.app.closeAllWindows()
|
|
|
|
|
|
|
|
# Count refreshing
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupRefreshTimer(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
# every 10 minutes
|
2019-12-23 01:34:10 +01:00
|
|
|
self.progress.timer(10 * 60 * 1000, self.onRefreshTimer, True)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onRefreshTimer(self):
|
|
|
|
if self.state == "deckBrowser":
|
|
|
|
self.deckBrowser.refresh()
|
|
|
|
elif self.state == "overview":
|
|
|
|
self.overview.refresh()
|
|
|
|
|
2013-05-22 05:27:37 +02:00
|
|
|
# Permanent libanki hooks
|
2012-12-21 08:51:59 +01:00
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupHooks(self) -> None:
|
2020-01-15 07:53:24 +01:00
|
|
|
hooks.schema_will_change.append(self.onSchemaMod)
|
2020-01-15 08:45:35 +01:00
|
|
|
hooks.notes_will_be_deleted.append(self.onRemNotes)
|
2020-01-15 07:53:24 +01:00
|
|
|
hooks.card_odue_was_invalid.append(self.onOdueInvalid)
|
2018-05-31 05:20:10 +02:00
|
|
|
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.mpv_will_play.append(self.on_mpv_will_play)
|
|
|
|
gui_hooks.mpv_did_idle.append(self.on_mpv_idle)
|
2020-01-13 05:38:05 +01:00
|
|
|
|
|
|
|
self._activeWindowOnPlay: Optional[QWidget] = None
|
2013-11-17 08:03:58 +01:00
|
|
|
|
|
|
|
def onOdueInvalid(self):
|
2019-12-23 01:34:10 +01:00
|
|
|
showWarning(
|
|
|
|
_(
|
|
|
|
"""\
|
2013-11-17 08:03:58 +01:00
|
|
|
Invalid property found on card. Please use Tools>Check Database, \
|
2019-12-23 01:34:10 +01:00
|
|
|
and if the problem comes up again, please ask on the support site."""
|
|
|
|
)
|
|
|
|
)
|
2013-05-22 05:27:37 +02:00
|
|
|
|
2018-07-23 05:19:01 +02:00
|
|
|
def _isVideo(self, file):
|
|
|
|
head, ext = os.path.splitext(file.lower())
|
|
|
|
return ext in (".mp4", ".mov", ".mpg", ".mpeg", ".mkv", ".avi")
|
|
|
|
|
2020-01-13 05:38:05 +01:00
|
|
|
def on_mpv_will_play(self, file: str) -> None:
|
2018-07-23 05:19:01 +02:00
|
|
|
if not self._isVideo(file):
|
|
|
|
return
|
|
|
|
|
|
|
|
self._activeWindowOnPlay = self.app.activeWindow() or self._activeWindowOnPlay
|
2018-05-31 05:20:10 +02:00
|
|
|
|
2020-01-13 05:38:05 +01:00
|
|
|
def on_mpv_idle(self) -> None:
|
2018-05-31 05:20:10 +02:00
|
|
|
w = self._activeWindowOnPlay
|
2018-07-23 05:19:01 +02:00
|
|
|
if not self.app.activeWindow() and w and not sip.isdeleted(w) and w.isVisible():
|
2018-05-31 05:20:10 +02:00
|
|
|
w.activateWindow()
|
|
|
|
w.raise_()
|
|
|
|
self._activeWindowOnPlay = None
|
2018-04-30 09:12:26 +02:00
|
|
|
|
2013-05-22 05:27:37 +02:00
|
|
|
# Log note deletion
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onRemNotes(self, col: _Collection, nids: List[int]) -> None:
|
2013-05-22 05:27:37 +02:00
|
|
|
path = os.path.join(self.pm.profileFolder(), "deleted.txt")
|
|
|
|
existed = os.path.exists(path)
|
2017-01-08 11:44:52 +01:00
|
|
|
with open(path, "ab") as f:
|
2013-05-22 05:27:37 +02:00
|
|
|
if not existed:
|
2017-01-08 11:44:52 +01:00
|
|
|
f.write(b"nid\tmid\tfields\n")
|
2013-05-31 03:42:24 +02:00
|
|
|
for id, mid, flds in col.db.execute(
|
2019-12-23 01:34:10 +01:00
|
|
|
"select id, mid, flds from notes where id in %s" % ids2str(nids)
|
|
|
|
):
|
2013-05-22 05:27:37 +02:00
|
|
|
fields = splitFields(flds)
|
2017-01-08 11:44:52 +01:00
|
|
|
f.write(("\t".join([str(id), str(mid)] + fields)).encode("utf8"))
|
|
|
|
f.write(b"\n")
|
2013-05-22 05:27:37 +02:00
|
|
|
|
|
|
|
# Schema modifications
|
|
|
|
##########################################################################
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onSchemaMod(self, arg):
|
2019-12-23 01:34:10 +01:00
|
|
|
return askUser(
|
|
|
|
_(
|
|
|
|
"""\
|
2012-12-21 08:51:59 +01:00
|
|
|
The requested change will require a full upload of the database when \
|
|
|
|
you next synchronize your collection. If you have reviews or other changes \
|
|
|
|
waiting on another device that haven't been synchronized here yet, they \
|
2019-12-23 01:34:10 +01:00
|
|
|
will be lost. Continue?"""
|
|
|
|
)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Advanced features
|
|
|
|
##########################################################################
|
|
|
|
|
|
|
|
def onCheckDB(self):
|
|
|
|
"True if no problems"
|
|
|
|
self.progress.start(immediate=True)
|
|
|
|
ret, ok = self.col.fixIntegrity()
|
|
|
|
self.progress.finish()
|
|
|
|
if not ok:
|
|
|
|
showText(ret)
|
|
|
|
else:
|
|
|
|
tooltip(ret)
|
2018-12-15 04:14:33 +01:00
|
|
|
|
|
|
|
# if an error has directed the user to check the database,
|
|
|
|
# silently clean up any broken reset hooks which distract from
|
|
|
|
# the underlying issue
|
|
|
|
while True:
|
|
|
|
try:
|
|
|
|
self.reset()
|
|
|
|
break
|
|
|
|
except Exception as e:
|
|
|
|
print("swallowed exception in reset hook:", e)
|
|
|
|
continue
|
2012-12-21 08:51:59 +01:00
|
|
|
return ret
|
|
|
|
|
|
|
|
def onCheckMediaDB(self):
|
|
|
|
self.progress.start(immediate=True)
|
2017-08-28 14:01:13 +02:00
|
|
|
(nohave, unused, warnings) = self.col.media.check()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.progress.finish()
|
|
|
|
# generate report
|
|
|
|
report = ""
|
2017-08-28 14:01:13 +02:00
|
|
|
if warnings:
|
|
|
|
report += "\n".join(warnings) + "\n"
|
2012-12-21 08:51:59 +01:00
|
|
|
if unused:
|
2019-10-20 01:39:43 +02:00
|
|
|
numberOfUnusedFilesLabel = len(unused)
|
2013-11-13 09:19:25 +01:00
|
|
|
if report:
|
|
|
|
report += "\n\n\n"
|
2019-12-23 01:34:10 +01:00
|
|
|
report += (
|
|
|
|
ngettext(
|
|
|
|
"%d file found in media folder not used by any cards:",
|
|
|
|
"%d files found in media folder not used by any cards:",
|
|
|
|
numberOfUnusedFilesLabel,
|
|
|
|
)
|
|
|
|
% numberOfUnusedFilesLabel
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
report += "\n" + "\n".join(unused)
|
|
|
|
if nohave:
|
|
|
|
if report:
|
|
|
|
report += "\n\n\n"
|
2019-12-23 01:34:10 +01:00
|
|
|
report += _("Used on cards but missing from media folder:")
|
2012-12-21 08:51:59 +01:00
|
|
|
report += "\n" + "\n".join(nohave)
|
|
|
|
if not report:
|
2013-07-23 18:04:37 +02:00
|
|
|
tooltip(_("No unused or missing files found."))
|
|
|
|
return
|
2012-12-21 08:51:59 +01:00
|
|
|
# show report and offer to delete
|
|
|
|
diag = QDialog(self)
|
|
|
|
diag.setWindowTitle("Anki")
|
|
|
|
layout = QVBoxLayout(diag)
|
|
|
|
diag.setLayout(layout)
|
|
|
|
text = QTextEdit()
|
|
|
|
text.setReadOnly(True)
|
|
|
|
text.setPlainText(report)
|
|
|
|
layout.addWidget(text)
|
|
|
|
box = QDialogButtonBox(QDialogButtonBox.Close)
|
|
|
|
layout.addWidget(box)
|
2018-03-01 05:00:05 +01:00
|
|
|
if unused:
|
|
|
|
b = QPushButton(_("Delete Unused Files"))
|
|
|
|
b.setAutoDefault(False)
|
|
|
|
box.addButton(b, QDialogButtonBox.ActionRole)
|
2019-12-23 01:34:10 +01:00
|
|
|
b.clicked.connect(lambda c, u=unused, d=diag: self.deleteUnused(u, d))
|
2018-03-01 05:00:05 +01:00
|
|
|
|
2016-05-31 10:51:40 +02:00
|
|
|
box.rejected.connect(diag.reject)
|
2012-12-21 08:51:59 +01:00
|
|
|
diag.setMinimumHeight(400)
|
|
|
|
diag.setMinimumWidth(500)
|
2014-06-18 20:47:45 +02:00
|
|
|
restoreGeom(diag, "checkmediadb")
|
2012-12-21 08:51:59 +01:00
|
|
|
diag.exec_()
|
2014-06-18 20:47:45 +02:00
|
|
|
saveGeom(diag, "checkmediadb")
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def deleteUnused(self, unused, diag):
|
2019-12-23 01:34:10 +01:00
|
|
|
if not askUser(_("Delete unused media?")):
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
mdir = self.col.media.dir()
|
2019-08-17 10:32:39 +02:00
|
|
|
self.progress.start(immediate=True)
|
|
|
|
try:
|
|
|
|
lastProgress = 0
|
|
|
|
for c, f in enumerate(unused):
|
|
|
|
path = os.path.join(mdir, f)
|
|
|
|
if os.path.exists(path):
|
|
|
|
send2trash(path)
|
|
|
|
|
|
|
|
now = time.time()
|
|
|
|
if now - lastProgress >= 0.3:
|
2019-10-20 00:03:59 +02:00
|
|
|
numberOfRemainingFilesToBeDeleted = len(unused) - c
|
2019-08-17 10:32:39 +02:00
|
|
|
lastProgress = now
|
2019-12-23 01:34:10 +01:00
|
|
|
label = (
|
|
|
|
ngettext(
|
|
|
|
"%d file remaining...",
|
|
|
|
"%d files remaining...",
|
|
|
|
numberOfRemainingFilesToBeDeleted,
|
|
|
|
)
|
|
|
|
% numberOfRemainingFilesToBeDeleted
|
|
|
|
)
|
2019-08-17 10:32:39 +02:00
|
|
|
self.progress.update(label)
|
|
|
|
finally:
|
|
|
|
self.progress.finish()
|
2019-10-22 04:22:30 +02:00
|
|
|
# caller must not pass in empty list
|
|
|
|
# pylint: disable=undefined-loop-variable
|
2019-10-20 00:03:59 +02:00
|
|
|
numberOfFilesDeleted = c + 1
|
2019-12-23 01:34:10 +01:00
|
|
|
tooltip(
|
|
|
|
ngettext("Deleted %d file.", "Deleted %d files.", numberOfFilesDeleted)
|
|
|
|
% numberOfFilesDeleted
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
diag.close()
|
|
|
|
|
|
|
|
def onStudyDeck(self):
|
|
|
|
from aqt.studydeck import StudyDeck
|
2019-12-23 01:34:10 +01:00
|
|
|
|
|
|
|
ret = StudyDeck(self, dyn=True, current=self.col.decks.current()["name"])
|
2012-12-21 08:51:59 +01:00
|
|
|
if ret.name:
|
|
|
|
self.col.decks.select(self.col.decks.id(ret.name))
|
|
|
|
self.moveToState("overview")
|
|
|
|
|
|
|
|
def onEmptyCards(self):
|
|
|
|
self.progress.start(immediate=True)
|
|
|
|
cids = self.col.emptyCids()
|
|
|
|
if not cids:
|
|
|
|
self.progress.finish()
|
|
|
|
tooltip(_("No empty cards."))
|
|
|
|
return
|
|
|
|
report = self.col.emptyCardReport(cids)
|
|
|
|
self.progress.finish()
|
|
|
|
part1 = ngettext("%d card", "%d cards", len(cids)) % len(cids)
|
|
|
|
part1 = _("%s to delete:") % part1
|
2019-12-23 01:34:10 +01:00
|
|
|
diag, box = showText(part1 + "\n\n" + report, run=False, geomKey="emptyCards")
|
2012-12-21 08:51:59 +01:00
|
|
|
box.addButton(_("Delete Cards"), QDialogButtonBox.AcceptRole)
|
|
|
|
box.button(QDialogButtonBox.Close).setDefault(True)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
def onDelete():
|
2014-06-18 20:47:45 +02:00
|
|
|
saveGeom(diag, "emptyCards")
|
2012-12-21 08:51:59 +01:00
|
|
|
QDialog.accept(diag)
|
|
|
|
self.checkpoint(_("Delete Empty"))
|
|
|
|
self.col.remCards(cids)
|
2019-12-23 01:34:10 +01:00
|
|
|
tooltip(
|
|
|
|
ngettext("%d card deleted.", "%d cards deleted.", len(cids)) % len(cids)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.reset()
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2016-05-31 10:51:40 +02:00
|
|
|
box.accepted.connect(onDelete)
|
2012-12-21 08:51:59 +01:00
|
|
|
diag.show()
|
|
|
|
|
|
|
|
# Debugging
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
def onDebug(self):
|
|
|
|
d = self.debugDiag = QDialog()
|
2017-08-25 04:14:59 +02:00
|
|
|
d.silentlyClose = True
|
2012-12-21 08:51:59 +01:00
|
|
|
frm = aqt.forms.debug.Ui_Dialog()
|
|
|
|
frm.setupUi(d)
|
2019-02-16 10:26:49 +01:00
|
|
|
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
|
|
|
|
font.setPointSize(frm.text.font().pointSize() + 1)
|
|
|
|
frm.text.setFont(font)
|
|
|
|
frm.log.setFont(font)
|
2012-12-21 08:51:59 +01:00
|
|
|
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+return"), d)
|
2016-05-31 10:51:40 +02:00
|
|
|
s.activated.connect(lambda: self.onDebugRet(frm))
|
2019-12-23 01:34:10 +01:00
|
|
|
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+return"), d)
|
2016-05-31 10:51:40 +02:00
|
|
|
s.activated.connect(lambda: self.onDebugPrint(frm))
|
2019-02-16 10:31:35 +01:00
|
|
|
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+l"), d)
|
|
|
|
s.activated.connect(frm.log.clear)
|
|
|
|
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+l"), d)
|
|
|
|
s.activated.connect(frm.text.clear)
|
2012-12-21 08:51:59 +01:00
|
|
|
d.show()
|
|
|
|
|
|
|
|
def _captureOutput(self, on):
|
|
|
|
mw = self
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2017-02-06 23:21:33 +01:00
|
|
|
class Stream:
|
2012-12-21 08:51:59 +01:00
|
|
|
def write(self, data):
|
|
|
|
mw._output += data
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
if on:
|
|
|
|
self._output = ""
|
|
|
|
self._oldStderr = sys.stderr
|
|
|
|
self._oldStdout = sys.stdout
|
|
|
|
s = Stream()
|
|
|
|
sys.stderr = s
|
|
|
|
sys.stdout = s
|
|
|
|
else:
|
|
|
|
sys.stderr = self._oldStderr
|
|
|
|
sys.stdout = self._oldStdout
|
|
|
|
|
|
|
|
def _debugCard(self):
|
|
|
|
return self.reviewer.card.__dict__
|
|
|
|
|
|
|
|
def _debugBrowserCard(self):
|
2019-12-23 01:34:10 +01:00
|
|
|
return aqt.dialogs._dialogs["Browser"][1].card.__dict__
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
def onDebugPrint(self, frm):
|
2019-02-16 10:57:09 +01:00
|
|
|
cursor = frm.text.textCursor()
|
|
|
|
position = cursor.position()
|
|
|
|
cursor.select(QTextCursor.LineUnderCursor)
|
|
|
|
line = cursor.selectedText()
|
|
|
|
pfx, sfx = "pp(", ")"
|
|
|
|
if not line.startswith(pfx):
|
|
|
|
line = "{}{}{}".format(pfx, line, sfx)
|
|
|
|
cursor.insertText(line)
|
|
|
|
cursor.setPosition(position + len(pfx))
|
|
|
|
frm.text.setTextCursor(cursor)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.onDebugRet(frm)
|
|
|
|
|
|
|
|
def onDebugRet(self, frm):
|
|
|
|
import pprint, traceback
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
text = frm.text.toPlainText()
|
|
|
|
card = self._debugCard
|
|
|
|
bcard = self._debugBrowserCard
|
|
|
|
mw = self
|
|
|
|
pp = pprint.pprint
|
|
|
|
self._captureOutput(True)
|
|
|
|
try:
|
2019-03-04 07:01:10 +01:00
|
|
|
# pylint: disable=exec-used
|
2016-05-12 06:45:35 +02:00
|
|
|
exec(text)
|
2012-12-21 08:51:59 +01:00
|
|
|
except:
|
|
|
|
self._output += traceback.format_exc()
|
|
|
|
self._captureOutput(False)
|
|
|
|
buf = ""
|
|
|
|
for c, line in enumerate(text.strip().split("\n")):
|
|
|
|
if c == 0:
|
|
|
|
buf += ">>> %s\n" % line
|
|
|
|
else:
|
|
|
|
buf += "... %s\n" % line
|
2013-04-11 08:25:59 +02:00
|
|
|
try:
|
|
|
|
frm.log.appendPlainText(buf + (self._output or "<no output>"))
|
|
|
|
except UnicodeDecodeError:
|
|
|
|
frm.log.appendPlainText(_("<non-unicode text>"))
|
2012-12-21 08:51:59 +01:00
|
|
|
frm.log.ensureCursorVisible()
|
|
|
|
|
|
|
|
# System specific code
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupSystemSpecific(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.hideMenuAccels = False
|
|
|
|
if isMac:
|
|
|
|
# mac users expect a minimize option
|
|
|
|
self.minimizeShortcut = QShortcut("Ctrl+M", self)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.minimizeShortcut.activated.connect(self.onMacMinimize) # type: ignore
|
2012-12-21 08:51:59 +01:00
|
|
|
self.hideMenuAccels = True
|
|
|
|
self.maybeHideAccelerators()
|
|
|
|
self.hideStatusTips()
|
|
|
|
elif isWin:
|
|
|
|
# make sure ctypes is bundled
|
2019-12-23 01:34:10 +01:00
|
|
|
from ctypes import windll, wintypes # type: ignore
|
|
|
|
|
2013-10-18 00:48:45 +02:00
|
|
|
_dummy = windll
|
|
|
|
_dummy = wintypes
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def maybeHideAccelerators(self, tgt: Optional[Any] = None) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.hideMenuAccels:
|
|
|
|
return
|
|
|
|
tgt = tgt or self
|
|
|
|
for action in tgt.findChildren(QAction):
|
2016-05-12 06:45:35 +02:00
|
|
|
txt = str(action.text())
|
2017-12-11 08:25:51 +01:00
|
|
|
m = re.match(r"^(.+)\(&.+\)(.+)?", txt)
|
2012-12-21 08:51:59 +01:00
|
|
|
if m:
|
|
|
|
action.setText(m.group(1) + (m.group(2) or ""))
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def hideStatusTips(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
for action in self.findChildren(QAction):
|
|
|
|
action.setStatusTip("")
|
|
|
|
|
|
|
|
def onMacMinimize(self):
|
|
|
|
self.setWindowState(self.windowState() | Qt.WindowMinimized)
|
|
|
|
|
|
|
|
# Single instance support
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupAppMsg(self) -> None:
|
2016-05-31 10:51:40 +02:00
|
|
|
self.app.appMsg.connect(self.onAppMsg)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def onAppMsg(self, buf: str) -> Optional[QTimer]:
|
2020-01-04 04:30:33 +01:00
|
|
|
is_addon = self._isAddon(buf)
|
2020-01-03 18:23:28 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
if self.state == "startup":
|
|
|
|
# try again in a second
|
2019-12-23 01:34:10 +01:00
|
|
|
return self.progress.timer(
|
|
|
|
1000, lambda: self.onAppMsg(buf), False, requiresCollection=False
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
elif self.state == "profileManager":
|
|
|
|
# can't raise window while in profile manager
|
|
|
|
if buf == "raise":
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2012-12-21 08:51:59 +01:00
|
|
|
self.pendingImport = buf
|
2020-01-03 17:57:33 +01:00
|
|
|
if is_addon:
|
|
|
|
msg = _("Add-on will be installed when a profile is opened.")
|
|
|
|
else:
|
|
|
|
msg = _("Deck will be imported when a profile is opened.")
|
|
|
|
return tooltip(msg)
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.interactiveState() or self.progress.busy():
|
|
|
|
# we can't raise the main window while in profile dialog, syncing, etc
|
|
|
|
if buf != "raise":
|
2019-12-23 01:34:10 +01:00
|
|
|
showInfo(
|
|
|
|
_(
|
|
|
|
"""\
|
|
|
|
Please ensure a profile is open and Anki is not busy, then try again."""
|
|
|
|
),
|
|
|
|
parent=None,
|
|
|
|
)
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2012-12-21 08:51:59 +01:00
|
|
|
# raise window
|
|
|
|
if isWin:
|
|
|
|
# on windows we can raise the window by minimizing and restoring
|
|
|
|
self.showMinimized()
|
|
|
|
self.setWindowState(Qt.WindowActive)
|
|
|
|
self.showNormal()
|
|
|
|
else:
|
|
|
|
# on osx we can raise the window. on unity the icon in the tray will just flash.
|
|
|
|
self.activateWindow()
|
|
|
|
self.raise_()
|
|
|
|
if buf == "raise":
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2020-01-03 18:23:28 +01:00
|
|
|
|
2020-01-03 17:57:33 +01:00
|
|
|
# import / add-on installation
|
|
|
|
if is_addon:
|
|
|
|
self.installAddon(buf)
|
|
|
|
else:
|
|
|
|
self.handleImport(buf)
|
2020-01-03 18:23:28 +01:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
return None
|
2016-07-04 05:22:35 +02:00
|
|
|
|
2020-01-04 04:30:33 +01:00
|
|
|
def _isAddon(self, buf: str) -> bool:
|
|
|
|
return buf.endswith(self.addonManager.ext)
|
|
|
|
|
2016-07-04 05:22:35 +02:00
|
|
|
# GC
|
|
|
|
##########################################################################
|
2017-01-08 05:42:50 +01:00
|
|
|
# ensure gc runs in main thread
|
2016-07-04 05:22:35 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupDialogGC(self, obj: Any) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
obj.finished.connect(lambda: self.gcWindow(obj)) # type: ignore
|
2016-07-04 05:22:35 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def gcWindow(self, obj: Any) -> None:
|
2016-07-04 05:22:35 +02:00
|
|
|
obj.deleteLater()
|
2019-02-06 02:37:01 +01:00
|
|
|
self.progress.timer(1000, self.doGC, False, requiresCollection=False)
|
2016-07-04 05:22:35 +02:00
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def disableGC(self) -> None:
|
2017-01-08 05:42:50 +01:00
|
|
|
gc.collect()
|
|
|
|
gc.disable()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def doGC(self) -> None:
|
2017-01-13 07:20:39 +01:00
|
|
|
assert not self.progress.inDB
|
2016-07-04 05:22:35 +02:00
|
|
|
gc.collect()
|
2016-07-07 15:39:48 +02:00
|
|
|
|
2017-01-08 04:38:12 +01:00
|
|
|
# Crash log
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupCrashLog(self) -> None:
|
2017-01-08 04:38:12 +01:00
|
|
|
p = os.path.join(self.pm.base, "crash.log")
|
2017-01-13 11:56:24 +01:00
|
|
|
self._crashLog = open(p, "ab", 0)
|
2017-01-08 04:38:12 +01:00
|
|
|
faulthandler.enable(self._crashLog)
|
|
|
|
|
2016-07-07 15:39:48 +02:00
|
|
|
# Media server
|
|
|
|
##########################################################################
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def setupMediaServer(self) -> None:
|
2019-03-02 18:57:51 +01:00
|
|
|
self.mediaServer = aqt.mediasrv.MediaServer(self)
|
2016-07-07 15:39:48 +02:00
|
|
|
self.mediaServer.start()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def baseHTML(self) -> str:
|
2017-08-11 12:37:04 +02:00
|
|
|
return '<base href="%s">' % self.serverURL()
|
|
|
|
|
2019-12-20 09:43:52 +01:00
|
|
|
def serverURL(self) -> str:
|
2018-11-12 13:23:47 +01:00
|
|
|
return "http://127.0.0.1:%d/" % self.mediaServer.getPort()
|