GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-18 22:12:21 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

use qconnect everywhere, and fix some typing issues

Browse source 
a step towards check_untyped_defs in aqt, but there's still 100+
issues to resolve
This commit is contained in:
Damien Elmes 2020-05-04 13:23:08 +10:00
parent 164fdb37d5
commit eec3fcf87a
35 changed files with 282 additions and 266 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
qt/aqt/__init__.py
View file

@ -255,7 +255,7 @@ class AnkiApp(QApplication):
# previous instance died
QLocalServer.removeServer(self.KEY)
self._srv = QLocalServer(self)
self._srv.newConnection.connect(self.onRecv)
qconnect(self._srv.newConnection, self.onRecv)
self._srv.listen(self.KEY)
return False

2
qt/aqt/about.py
View file

@ -86,7 +86,7 @@ def show(mw):
tooltip(_("Copied to clipboard"), parent=dialog)
btn = QPushButton(_("Copy Debug Info"))
btn.clicked.connect(onCopy)
qconnect(btn.clicked, onCopy)
abt.buttonBox.addButton(btn, QDialogButtonBox.ActionRole)
abt.buttonBox.button(QDialogButtonBox.Ok).setFocus()

4
qt/aqt/addcards.py
View file

@ -65,7 +65,7 @@ class AddCards(QDialog):
ar = QDialogButtonBox.ActionRole
# add
self.addButton = bb.addButton(_("Add"), ar)
self.addButton.clicked.connect(self.addCards)
qconnect(self.addButton.clicked, self.addCards)
self.addButton.setShortcut(QKeySequence("Ctrl+Return"))
self.addButton.setToolTip(shortcut(_("Add (shortcut: ctrl+enter)")))
# close
@ -84,7 +84,7 @@ class AddCards(QDialog):
sc = "Ctrl+H"
b.setShortcut(QKeySequence(sc))
b.setToolTip(_("Shortcut: %s") % shortcut(sc))
b.clicked.connect(self.onHistory)
qconnect(b.clicked, self.onHistory)
b.setEnabled(False)
self.historyButton = b

28
qt/aqt/addons.py
View file

@ -175,7 +175,7 @@ class AddonManager:
self.mw = mw
self.dirty = False
f = self.mw.form
f.actionAdd_ons.triggered.connect(self.onAddonsDialog)
qconnect(f.actionAdd_ons.triggered, self.onAddonsDialog)
sys.path.insert(0, self.addonsFolder())
# in new code, you may want all_addon_meta() instead
@ -699,16 +699,16 @@ class AddonsDialog(QDialog):
f = self.form = aqt.forms.addons.Ui_Dialog()
f.setupUi(self)
f.getAddons.clicked.connect(self.onGetAddons)
f.installFromFile.clicked.connect(self.onInstallFiles)
f.checkForUpdates.clicked.connect(self.check_for_updates)
f.toggleEnabled.clicked.connect(self.onToggleEnabled)
f.viewPage.clicked.connect(self.onViewPage)
f.viewFiles.clicked.connect(self.onViewFiles)
f.delete_2.clicked.connect(self.onDelete)
f.config.clicked.connect(self.onConfig)
self.form.addonList.itemDoubleClicked.connect(self.onConfig)
self.form.addonList.currentRowChanged.connect(self._onAddonItemSelected)
qconnect(f.getAddons.clicked, self.onGetAddons)
qconnect(f.installFromFile.clicked, self.onInstallFiles)
qconnect(f.checkForUpdates.clicked, self.check_for_updates)
qconnect(f.toggleEnabled.clicked, self.onToggleEnabled)
qconnect(f.viewPage.clicked, self.onViewPage)
qconnect(f.viewFiles.clicked, self.onViewFiles)
qconnect(f.delete_2.clicked, self.onDelete)
qconnect(f.config.clicked, self.onConfig)
qconnect(self.form.addonList.itemDoubleClicked, self.onConfig)
qconnect(self.form.addonList.currentRowChanged, self._onAddonItemSelected)
self.setAcceptDrops(True)
self.redrawAddons()
restoreGeom(self, "addons")
@ -916,7 +916,7 @@ class GetAddons(QDialog):
b = self.form.buttonBox.addButton(
_("Browse Add-ons"), QDialogButtonBox.ActionRole
)
b.clicked.connect(self.onBrowse)
qconnect(b.clicked, self.onBrowse)
restoreGeom(self, "getaddons", adjustSize=True)
self.exec_()
saveGeom(self, "getaddons")
@ -1057,7 +1057,7 @@ class DownloaderInstaller(QObject):
QObject.__init__(self, parent)
self.mgr = mgr
self.client = client
self.progressSignal.connect(self._progress_callback) # type: ignore
qconnect(self.progressSignal, self._progress_callback)
def bg_thread_progress(up, down) -> None:
self.progressSignal.emit(up, down) # type: ignore
@ -1283,7 +1283,7 @@ class ConfigEditor(QDialog):
self.form = aqt.forms.addonconf.Ui_Dialog()
self.form.setupUi(self)
restore = self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults)
restore.clicked.connect(self.onRestoreDefaults)
qconnect(restore.clicked, self.onRestoreDefaults)
self.setupFonts()
self.updateHelp()
self.updateText(self.conf)

113
qt/aqt/browser.py
View file

@ -608,53 +608,53 @@ class Browser(QMainWindow):
# pylint: disable=unnecessary-lambda
# actions
f = self.form
f.previewButton.clicked.connect(self.onTogglePreview)
qconnect(f.previewButton.clicked, self.onTogglePreview)
f.previewButton.setToolTip(
_("Preview Selected Card (%s)") % shortcut("Ctrl+Shift+P")
)
f.previewButton.setShortcut("Ctrl+Shift+P")
f.filter.clicked.connect(self.onFilterButton)
qconnect(f.filter.clicked, self.onFilterButton)
# edit
f.actionUndo.triggered.connect(self.mw.onUndo)
f.actionInvertSelection.triggered.connect(self.invertSelection)
f.actionSelectNotes.triggered.connect(self.selectNotes)
qconnect(f.actionUndo.triggered, self.mw.onUndo)
qconnect(f.actionInvertSelection.triggered, self.invertSelection)
qconnect(f.actionSelectNotes.triggered, self.selectNotes)
if not isMac:
f.actionClose.setVisible(False)
# notes
f.actionAdd.triggered.connect(self.mw.onAddCard)
f.actionAdd_Tags.triggered.connect(lambda: self.addTags())
f.actionRemove_Tags.triggered.connect(lambda: self.deleteTags())
f.actionClear_Unused_Tags.triggered.connect(self.clearUnusedTags)
f.actionToggle_Mark.triggered.connect(lambda: self.onMark())
f.actionChangeModel.triggered.connect(self.onChangeModel)
f.actionFindDuplicates.triggered.connect(self.onFindDupes)
f.actionFindReplace.triggered.connect(self.onFindReplace)
f.actionManage_Note_Types.triggered.connect(self.mw.onNoteTypes)
f.actionDelete.triggered.connect(self.deleteNotes)
qconnect(f.actionAdd.triggered, self.mw.onAddCard)
qconnect(f.actionAdd_Tags.triggered, lambda: self.addTags())
qconnect(f.actionRemove_Tags.triggered, lambda: self.deleteTags())
qconnect(f.actionClear_Unused_Tags.triggered, self.clearUnusedTags)
qconnect(f.actionToggle_Mark.triggered, lambda: self.onMark())
qconnect(f.actionChangeModel.triggered, self.onChangeModel)
qconnect(f.actionFindDuplicates.triggered, self.onFindDupes)
qconnect(f.actionFindReplace.triggered, self.onFindReplace)
qconnect(f.actionManage_Note_Types.triggered, self.mw.onNoteTypes)
qconnect(f.actionDelete.triggered, self.deleteNotes)
# cards
f.actionChange_Deck.triggered.connect(self.setDeck)
f.action_Info.triggered.connect(self.showCardInfo)
f.actionReposition.triggered.connect(self.reposition)
f.actionReschedule.triggered.connect(self.reschedule)
f.actionToggle_Suspend.triggered.connect(self.onSuspend)
f.actionRed_Flag.triggered.connect(lambda: self.onSetFlag(1))
f.actionOrange_Flag.triggered.connect(lambda: self.onSetFlag(2))
f.actionGreen_Flag.triggered.connect(lambda: self.onSetFlag(3))
f.actionBlue_Flag.triggered.connect(lambda: self.onSetFlag(4))
f.actionExport.triggered.connect(lambda: self._on_export_notes())
qconnect(f.actionChange_Deck.triggered, self.setDeck)
qconnect(f.action_Info.triggered, self.showCardInfo)
qconnect(f.actionReposition.triggered, self.reposition)
qconnect(f.actionReschedule.triggered, self.reschedule)
qconnect(f.actionToggle_Suspend.triggered, self.onSuspend)
qconnect(f.actionRed_Flag.triggered, lambda: self.onSetFlag(1))
qconnect(f.actionOrange_Flag.triggered, lambda: self.onSetFlag(2))
qconnect(f.actionGreen_Flag.triggered, lambda: self.onSetFlag(3))
qconnect(f.actionBlue_Flag.triggered, lambda: self.onSetFlag(4))
qconnect(f.actionExport.triggered, lambda: self._on_export_notes())
# jumps
f.actionPreviousCard.triggered.connect(self.onPreviousCard)
f.actionNextCard.triggered.connect(self.onNextCard)
f.actionFirstCard.triggered.connect(self.onFirstCard)
f.actionLastCard.triggered.connect(self.onLastCard)
f.actionFind.triggered.connect(self.onFind)
f.actionNote.triggered.connect(self.onNote)
f.actionTags.triggered.connect(self.onFilterButton)
f.actionSidebar.triggered.connect(self.focusSidebar)
f.actionCardList.triggered.connect(self.onCardList)
qconnect(f.actionPreviousCard.triggered, self.onPreviousCard)
qconnect(f.actionNextCard.triggered, self.onNextCard)
qconnect(f.actionFirstCard.triggered, self.onFirstCard)
qconnect(f.actionLastCard.triggered, self.onLastCard)
qconnect(f.actionFind.triggered, self.onFind)
qconnect(f.actionNote.triggered, self.onNote)
qconnect(f.actionTags.triggered, self.onFilterButton)
qconnect(f.actionSidebar.triggered, self.focusSidebar)
qconnect(f.actionCardList.triggered, self.onCardList)
# help
f.actionGuide.triggered.connect(self.onHelp)
qconnect(f.actionGuide.triggered, self.onHelp)
# keyboard shortcut for shift+home/end
self.pgUpCut = QShortcut(QKeySequence("Shift+Home"), self)
qconnect(self.pgUpCut.activated, self.onFirstCard)
@ -666,7 +666,7 @@ class Browser(QMainWindow):
# context menu
self.form.tableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.form.tableView.customContextMenuRequested.connect(self.onContextMenu)
qconnect(self.form.tableView.customContextMenuRequested, self.onContextMenu)
def onContextMenu(self, _point) -> None:
m = QMenu()
@ -750,8 +750,8 @@ class Browser(QMainWindow):
######################################################################
def setupSearch(self):
self.form.searchButton.clicked.connect(self.onSearchActivated)
self.form.searchEdit.lineEdit().returnPressed.connect(self.onSearchActivated)
qconnect(self.form.searchButton.clicked, self.onSearchActivated)
qconnect(self.form.searchEdit.lineEdit().returnPressed, self.onSearchActivated)
self.form.searchEdit.setCompleter(None)
self._searchPrompt = _("<type here to search; hit enter to show current deck>")
self.form.searchEdit.addItems(
@ -837,7 +837,9 @@ class Browser(QMainWindow):
self.form.tableView.setModel(self.model)
self.form.tableView.selectionModel()
self.form.tableView.setItemDelegate(StatusDelegate(self, self.model))
self.form.tableView.selectionModel().selectionChanged.connect(self.onRowChanged)
qconnect(
self.form.tableView.selectionModel().selectionChanged, self.onRowChanged
)
self.form.tableView.setWordWrap(False)
if not theme_manager.night_mode:
self.form.tableView.setStyleSheet(
@ -912,10 +914,10 @@ QTableView {{ gridline-color: {grid} }}
hh.setSectionsMovable(True)
self.setColumnSizes()
hh.setContextMenuPolicy(Qt.CustomContextMenu)
hh.customContextMenuRequested.connect(self.onHeaderContext)
qconnect(hh.customContextMenuRequested, self.onHeaderContext)
self.setSortIndicator()
hh.sortIndicatorChanged.connect(self.onSortChanged)
hh.sectionMoved.connect(self.onColumnMoved)
qconnect(hh.sortIndicatorChanged, self.onSortChanged)
qconnect(hh.sectionMoved, self.onColumnMoved)
def onSortChanged(self, idx, ord):
ord = bool(ord)
@ -969,7 +971,7 @@ QTableView {{ gridline-color: {grid} }}
a = m.addAction(name)
a.setCheckable(True)
a.setChecked(type in self.model.activeCols)
a.toggled.connect(lambda b, t=type: self.toggleField(t))
qconnect(a.toggled, lambda b, t=type: self.toggleField(t))
gui_hooks.browser_header_will_show_context_menu(self, m)
m.exec_(gpos)
@ -1015,8 +1017,8 @@ QTableView {{ gridline-color: {grid} }}
class SidebarTreeView(QTreeView):
def __init__(self):
super().__init__()
self.expanded.connect(self.onExpansion)
self.collapsed.connect(self.onCollapse)
qconnect(self.expanded, self.onExpansion)
qconnect(self.collapsed, self.onCollapse)
def onClickCurrent(self) -> None:
idx = self.currentIndex()
@ -1058,13 +1060,13 @@ QTableView {{ gridline-color: {grid} }}
self.sidebarTree.setUniformRowHeights(True)
self.sidebarTree.setHeaderHidden(True)
self.sidebarTree.setIndentation(15)
self.sidebarTree.expanded.connect(self.onSidebarItemExpanded) # type: ignore
qconnect(self.sidebarTree.expanded, self.onSidebarItemExpanded)
dw.setWidget(self.sidebarTree)
# match window background color
bgcolor = QPalette().window().color().name()
self.sidebarTree.setStyleSheet("QTreeView { background: '%s'; }" % bgcolor)
self.sidebarDockWidget.setFloating(False)
self.sidebarDockWidget.visibilityChanged.connect(self.onSidebarVisChanged) # type: ignore
qconnect(self.sidebarDockWidget.visibilityChanged, self.onSidebarVisChanged)
self.sidebarDockWidget.setTitleBarWidget(QWidget())
self.addDockWidget(Qt.LeftDockWidgetArea, dw)
@ -1428,7 +1430,7 @@ QTableView {{ gridline-color: {grid} }}
w.stdHtml(info + "<p>" + reps, context=card_info_dialog)
bb = QDialogButtonBox(QDialogButtonBox.Close)
l.addWidget(bb)
bb.rejected.connect(card_info_dialog.reject)
qconnect(bb.rejected, card_info_dialog.reject)
card_info_dialog.setLayout(l)
card_info_dialog.setWindowModality(Qt.WindowModal)
card_info_dialog.resize(500, 400)
@ -1932,7 +1934,7 @@ update cards set usn=?, mod=?, did=? where id in """
frm.setupUi(d)
d.setWindowModality(Qt.WindowModal)
frm.field.addItems([_("All Fields")] + fields)
frm.buttonBox.helpRequested.connect(self.onFindReplaceHelp)
qconnect(frm.buttonBox.helpRequested, self.onFindReplaceHelp)
restoreGeom(d, "findreplace")
r = d.exec_()
saveGeom(d, "findreplace")
@ -2000,7 +2002,7 @@ update cards set usn=?, mod=?, did=? where id in """
def onFin(code):
saveGeom(d, "findDupes")
d.finished.connect(onFin)
qconnect(d.finished, onFin)
def onClick():
field = fields[frm.fields.currentIndex()]
@ -2009,7 +2011,7 @@ update cards set usn=?, mod=?, did=? where id in """
)
search = frm.buttonBox.addButton(_("Search"), QDialogButtonBox.ActionRole)
search.clicked.connect(onClick)
qconnect(search.clicked, onClick)
d.show()
def duplicatesReport(self, web, fname, search, frm, web_context):
@ -2019,7 +2021,7 @@ update cards set usn=?, mod=?, did=? where id in """
self._dupesButton = b = frm.buttonBox.addButton(
_("Tag Duplicates"), QDialogButtonBox.ActionRole
)
b.clicked.connect(lambda: self._onTagDupes(res))
qconnect(b.clicked, lambda: self._onTagDupes(res))
t = ""
groups = len(res)
notes = sum(len(r[1]) for r in res)
@ -2179,7 +2181,7 @@ class ChangeModel(QDialog):
self.browser.mw, self.form.modelChooserWidget, label=False
)
self.modelChooser.models.setFocus()
self.form.buttonBox.helpRequested.connect(self.onHelp)
qconnect(self.form.buttonBox.helpRequested, self.onHelp)
self.modelChanged(self.browser.mw.col.models.current())
self.pauseUpdate = False
@ -2215,8 +2217,9 @@ class ChangeModel(QDialog):
idx = min(i, len(targets) - 1)
cb.setCurrentIndex(idx)
indices[cb] = idx
cb.currentIndexChanged.connect(
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key)
qconnect(
cb.currentIndexChanged,
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key),
)
combos.append(cb)
l.addWidget(cb, i, 1)

37
qt/aqt/clayout.py
View file

@ -106,8 +106,8 @@ class CardLayout(QDialog):
self.topAreaForm = aqt.forms.clayout_top.Ui_Form()
self.topAreaForm.setupUi(self.topArea)
self.topAreaForm.templateOptions.setText(_("Options") + " " + downArrow())
self.topAreaForm.templateOptions.clicked.connect(self.onMore)
self.topAreaForm.templatesBox.currentIndexChanged.connect(self.onCardSelected)
qconnect(self.topAreaForm.templateOptions.clicked, self.onMore)
qconnect(self.topAreaForm.templatesBox.currentIndexChanged, self.onCardSelected)
def updateTopArea(self):
cnt = self.mw.col.models.useCount(self.model)
@ -184,13 +184,14 @@ class CardLayout(QDialog):
tform.tlayout2.setContentsMargins(0, 11, 0, 0)
tform.tlayout3.setContentsMargins(0, 11, 0, 0)
tform.groupBox_3.setTitle(_("Styling (shared between cards)"))
tform.front.textChanged.connect(self.saveCard)
tform.css.textChanged.connect(self.saveCard)
tform.back.textChanged.connect(self.saveCard)
qconnect(tform.front.textChanged, self.saveCard)
qconnect(tform.css.textChanged, self.saveCard)
qconnect(tform.back.textChanged, self.saveCard)
l.addWidget(left, 5)
# preview area
right = QWidget()
pform = self.pform = aqt.forms.preview.Ui_Form()
self.pform: Any = aqt.forms.preview.Ui_Form()
pform = self.pform
pform.setupUi(right)
if self.style().objectName() == "gtk+":
# gtk+ requires margins in inner layout
@ -269,22 +270,22 @@ Please create a new card type first."""
help = QPushButton(_("Help"))
help.setAutoDefault(False)
l.addWidget(help)
help.clicked.connect(self.onHelp)
qconnect(help.clicked, self.onHelp)
l.addStretch()
addField = QPushButton(_("Add Field"))
addField.setAutoDefault(False)
l.addWidget(addField)
addField.clicked.connect(self.onAddField)
qconnect(addField.clicked, self.onAddField)
if not self._isCloze():
flip = QPushButton(_("Flip"))
flip.setAutoDefault(False)
l.addWidget(flip)
flip.clicked.connect(self.onFlip)
qconnect(flip.clicked, self.onFlip)
l.addStretch()
close = QPushButton(_("Close"))
close.setAutoDefault(False)
l.addWidget(close)
close.clicked.connect(self.accept)
qconnect(close.clicked, self.accept)
# Cards
##########################################################################
@ -471,16 +472,16 @@ adjust the template manually to switch the question and answer."""
if not self._isCloze():
a = m.addAction(_("Add Card Type..."))
a.triggered.connect(self.onAddCard)
qconnect(a.triggered, self.onAddCard)
a = m.addAction(_("Remove Card Type..."))
a.triggered.connect(self.onRemove)
qconnect(a.triggered, self.onRemove)
a = m.addAction(_("Rename Card Type..."))
a.triggered.connect(self.onRename)
qconnect(a.triggered, self.onRename)
a = m.addAction(_("Reposition Card Type..."))
a.triggered.connect(self.onReorder)
qconnect(a.triggered, self.onReorder)
m.addSeparator()
@ -490,10 +491,10 @@ adjust the template manually to switch the question and answer."""
else:
s = _(" (off)")
a = m.addAction(_("Deck Override...") + s)
a.triggered.connect(self.onTargetDeck)
qconnect(a.triggered, self.onTargetDeck)
a = m.addAction(_("Browser Appearance..."))
a.triggered.connect(self.onBrowserDisplay)
qconnect(a.triggered, self.onBrowserDisplay)
m.exec_(self.topAreaForm.templateOptions.mapToGlobal(QPoint(0, 0)))
@ -508,7 +509,7 @@ adjust the template manually to switch the question and answer."""
f.overrideFont.setChecked(True)
f.font.setCurrentFont(QFont(t.get("bfont", "Arial")))
f.fontSize.setValue(t.get("bsize", 12))
f.buttonBox.accepted.connect(lambda: self.onBrowserDisplayOk(f))
qconnect(f.buttonBox.accepted, lambda: self.onBrowserDisplayOk(f))
d.exec_()
def onBrowserDisplayOk(self, f):
@ -547,7 +548,7 @@ Enter deck to place new %s cards in, or leave blank:"""
te.setText(self.col.decks.get(t["did"])["name"])
te.selectAll()
bb = QDialogButtonBox(QDialogButtonBox.Close)
bb.rejected.connect(d.close)
qconnect(bb.rejected, d.close)
l.addWidget(bb)
d.setLayout(l)
d.exec_()

12
qt/aqt/customstudy.py
View file

@ -37,12 +37,12 @@ class CustomStudy(QDialog):
def setupSignals(self):
f = self.form
f.radioNew.clicked.connect(lambda: self.onRadioChange(RADIO_NEW))
f.radioRev.clicked.connect(lambda: self.onRadioChange(RADIO_REV))
f.radioForgot.clicked.connect(lambda: self.onRadioChange(RADIO_FORGOT))
f.radioAhead.clicked.connect(lambda: self.onRadioChange(RADIO_AHEAD))
f.radioPreview.clicked.connect(lambda: self.onRadioChange(RADIO_PREVIEW))
f.radioCram.clicked.connect(lambda: self.onRadioChange(RADIO_CRAM))
qconnect(f.radioNew.clicked, lambda: self.onRadioChange(RADIO_NEW))
qconnect(f.radioRev.clicked, lambda: self.onRadioChange(RADIO_REV))
qconnect(f.radioForgot.clicked, lambda: self.onRadioChange(RADIO_FORGOT))
qconnect(f.radioAhead.clicked, lambda: self.onRadioChange(RADIO_AHEAD))
qconnect(f.radioPreview.clicked, lambda: self.onRadioChange(RADIO_PREVIEW))
qconnect(f.radioCram.clicked, lambda: self.onRadioChange(RADIO_CRAM))
def onRadioChange(self, idx):
f = self.form

21
qt/aqt/deckconf.py
View file

@ -36,10 +36,11 @@ class DeckConf(QDialog):
self.setupCombos()
self.setupConfs()
self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("deckoptions"))
self.form.confOpts.clicked.connect(self.confOpts)
self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults).clicked.connect(
self.onRestore
qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("deckoptions"))
qconnect(self.form.confOpts.clicked, self.confOpts)
qconnect(
self.form.buttonBox.button(QDialogButtonBox.RestoreDefaults).clicked,
self.onRestore,
)
self.setWindowTitle(_("Options for %s") % self.deck["name"])
# qt doesn't size properly with altered fonts otherwise
@ -54,13 +55,13 @@ class DeckConf(QDialog):
f = self.form
f.newOrder.addItems(list(cs.newCardOrderLabels().values()))
f.newOrder.currentIndexChanged.connect(self.onNewOrderChanged)
qconnect(f.newOrder.currentIndexChanged, self.onNewOrderChanged)
# Conf list
######################################################################
def setupConfs(self):
self.form.dconf.currentIndexChanged.connect(self.onConfChange)
qconnect(self.form.dconf.currentIndexChanged, self.onConfChange)
self.conf = None
self.loadConfs()
@ -84,13 +85,13 @@ class DeckConf(QDialog):
def confOpts(self):
m = QMenu(self.mw)
a = m.addAction(_("Add"))
a.triggered.connect(self.addGroup)
qconnect(a.triggered, self.addGroup)
a = m.addAction(_("Delete"))
a.triggered.connect(self.remGroup)
qconnect(a.triggered, self.remGroup)
a = m.addAction(_("Rename"))
a.triggered.connect(self.renameGroup)
qconnect(a.triggered, self.renameGroup)
a = m.addAction(_("Set for all subdecks"))
a.triggered.connect(self.setChildren)
qconnect(a.triggered, self.setChildren)
if not self.childDids:
a.setEnabled(False)
m.exec_(QCursor.pos())

4
qt/aqt/dyndeckconf.py
View file

@ -23,7 +23,7 @@ class DeckConf(QDialog):
self.ok = self.form.buttonBox.addButton(label, QDialogButtonBox.AcceptRole)
self.mw.checkpoint(_("Options"))
self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("filtered"))
qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("filtered"))
self.setWindowTitle(_("Options for %s") % self.deck["name"])
restoreGeom(self, "dyndeckconf")
self.initialSetup()
@ -46,7 +46,7 @@ class DeckConf(QDialog):
self.form.order.addItems(list(cs.dynOrderLabels().values()))
self.form.order_2.addItems(list(cs.dynOrderLabels().values()))
self.form.resched.stateChanged.connect(self._onReschedToggled)
qconnect(self.form.resched.stateChanged, self._onReschedToggled)
def _onReschedToggled(self, _state):
self.form.previewDelayWidget.setVisible(

8
qt/aqt/editor.py
View file

@ -521,7 +521,7 @@ class Editor:
d = QDialog(self.widget)
form = aqt.forms.edithtml.Ui_Dialog()
form.setupUi(d)
form.buttonBox.helpRequested.connect(lambda: openHelp("editor"))
qconnect(form.buttonBox.helpRequested, lambda: openHelp("editor"))
form.textEdit.setPlainText(self.note.fields[field])
d.show()
form.textEdit.moveCursor(QTextCursor.End)
@ -553,7 +553,7 @@ class Editor:
l = QLabel(_("Tags"))
tb.addWidget(l, 1, 0)
self.tags = aqt.tagedit.TagEdit(self.widget)
self.tags.lostFocus.connect(self.saveTags)
qconnect(self.tags.lostFocus, self.saveTags)
self.tags.setToolTip(shortcut(_("Jump to tags with Ctrl+Shift+T")))
border = theme_manager.str_color("border")
self.tags.setStyleSheet(f"border: 1px solid {border}")
@ -921,7 +921,7 @@ to a cloze type first, via Edit>Change Note Type."""
(_("Edit HTML"), self.onHtmlEdit, "Ctrl+Shift+X"),
):
a = m.addAction(text)
a.triggered.connect(handler)
qconnect(a.triggered, handler)
a.setShortcut(QKeySequence(shortcut))
qtMenuShortcutWorkaround(m)
@ -985,7 +985,7 @@ class EditorWebView(AnkiWebView):
self.setAcceptDrops(True)
self._markInternal = False
clip = self.editor.mw.app.clipboard()
clip.dataChanged.connect(self._onClipboardChange)
qconnect(clip.dataChanged, self._onClipboardChange)
gui_hooks.editor_web_view_did_init(self)
def _onClipboardChange(self):

4
qt/aqt/errors.py
View file

@ -34,7 +34,7 @@ class ErrorHandler(QObject):
QObject.__init__(self, mw)
self.mw = mw
self.timer = None
self.errorTimer.connect(self._setTimer)
qconnect(self.errorTimer, self._setTimer)
self.pool = ""
self._oldstderr = sys.stderr
sys.stderr = self
@ -59,7 +59,7 @@ class ErrorHandler(QObject):
def _setTimer(self):
if not self.timer:
self.timer = QTimer(self.mw)
self.timer.timeout.connect(self.onTimeout)
qconnect(self.timer.timeout, self.onTimeout)
self.timer.setInterval(self.ivl)
self.timer.setSingleShot(True)
self.timer.start()

6
qt/aqt/exporting.py
View file

@ -11,7 +11,7 @@ from typing import List, Optional
import aqt
from anki import hooks
from anki.exporting import exporters
from anki.exporting import Exporter, exporters
from anki.lang import _, ngettext
from aqt.qt import *
from aqt.utils import checkInvalidFilename, getSaveFile, showWarning, tooltip
@ -29,7 +29,7 @@ class ExportDialog(QDialog):
self.col = mw.col.weakref()
self.frm = aqt.forms.exporting.Ui_ExportDialog()
self.frm.setupUi(self)
self.exporter = None
self.exporter: Optional[Exporter] = None
self.cids = cids
self.setup(did)
self.exec_()
@ -45,7 +45,7 @@ class ExportDialog(QDialog):
break
self.frm.format.insertItems(0, [e[0] for e in self.exporters])
self.frm.format.setCurrentIndex(idx)
self.frm.format.activated.connect(self.exporterChanged)
qconnect(self.frm.format.activated, self.exporterChanged)
self.exporterChanged(idx)
# deck list
if self.cids is None:

14
qt/aqt/fields.py
View file

@ -42,13 +42,13 @@ class FieldDialog(QDialog):
def setupSignals(self):
f = self.form
f.fieldList.currentRowChanged.connect(self.onRowChange)
f.fieldAdd.clicked.connect(self.onAdd)
f.fieldDelete.clicked.connect(self.onDelete)
f.fieldRename.clicked.connect(self.onRename)
f.fieldPosition.clicked.connect(self.onPosition)
f.sortField.clicked.connect(self.onSortField)
f.buttonBox.helpRequested.connect(self.onHelp)
qconnect(f.fieldList.currentRowChanged, self.onRowChange)
qconnect(f.fieldAdd.clicked, self.onAdd)
qconnect(f.fieldDelete.clicked, self.onDelete)
qconnect(f.fieldRename.clicked, self.onRename)
qconnect(f.fieldPosition.clicked, self.onPosition)
qconnect(f.sortField.clicked, self.onSortField)
qconnect(f.buttonBox.helpRequested, self.onHelp)
def onDrop(self, ev):
fieldList = self.form.fieldList

10
qt/aqt/importing.py
View file

@ -83,18 +83,18 @@ class ImportDialog(QDialog):
self.importer = importer
self.frm = aqt.forms.importing.Ui_ImportDialog()
self.frm.setupUi(self)
self.frm.buttonBox.button(QDialogButtonBox.Help).clicked.connect(
self.helpRequested
qconnect(
self.frm.buttonBox.button(QDialogButtonBox.Help).clicked, self.helpRequested
)
self.setupMappingFrame()
self.setupOptions()
self.modelChanged()
self.frm.autoDetect.setVisible(self.importer.needDelimiter)
gui_hooks.current_note_type_did_change.append(self.modelChanged)
self.frm.autoDetect.clicked.connect(self.onDelimiter)
qconnect(self.frm.autoDetect.clicked, self.onDelimiter)
self.updateDelimiterButtonText()
self.frm.allowHTML.setChecked(self.mw.pm.profile.get("allowHTML", True))
self.frm.importMode.currentIndexChanged.connect(self.importModeChanged)
qconnect(self.frm.importMode.currentIndexChanged, self.importModeChanged)
self.frm.importMode.setCurrentIndex(self.mw.pm.profile.get("importMode", 1))
self.frm.tagModified.setText(self.mw.pm.profile.get("tagModified", ""))
self.frm.tagModified.setCol(self.mw.col)
@ -266,7 +266,7 @@ you can enter it here. Use \\t to represent tab."""
self.grid.addWidget(QLabel(text), num, 1)
button = QPushButton(_("Change"))
self.grid.addWidget(button, num, 2)
button.clicked.connect(lambda _, s=self, n=num: s.changeMappingNum(n))
qconnect(button.clicked, lambda _, s=self, n=num: s.changeMappingNum(n))
def changeMappingNum(self, n):
f = ChangeMap(self.mw, self.importer.model, self.mapping[n]).getField()

12
qt/aqt/legacy.py
View file

@ -38,9 +38,9 @@ def fmtTimeSpan(time, pad=0, point=0, short=False, inTime=False, unit=99):
return aqt.mw.col.backend.format_time_span(time)
def install_pylib_legacy():
anki.utils.bodyClass = bodyClass
anki.utils.fmtTimeSpan = fmtTimeSpan
anki.sound._soundReg = r"\[sound:(.*?)\]"
anki.sound.allSounds = allSounds
anki.sound.stripSounds = stripSounds
def install_pylib_legacy() -> None:
anki.utils.bodyClass = bodyClass # type: ignore
anki.utils.fmtTimeSpan = fmtTimeSpan # type: ignore
anki.sound._soundReg = r"\[sound:(.*?)\]" # type: ignore
anki.sound.allSounds = allSounds # type: ignore
anki.sound.stripSounds = stripSounds # type: ignore

74
qt/aqt/main.py
View file

@ -204,17 +204,17 @@ class AnkiQt(QMainWindow):
d = self.profileDiag = self.ProfileManager()
f = self.profileForm = aqt.forms.profiles.Ui_MainWindow()
f.setupUi(d)
f.login.clicked.connect(self.onOpenProfile)
f.profiles.itemDoubleClicked.connect(self.onOpenProfile)
f.openBackup.clicked.connect(self.onOpenBackup)
f.quit.clicked.connect(d.close)
d.onClose.connect(self.cleanupAndExit)
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)
qconnect(f.login.clicked, self.onOpenProfile)
qconnect(f.profiles.itemDoubleClicked, self.onOpenProfile)
qconnect(f.openBackup.clicked, self.onOpenBackup)
qconnect(f.quit.clicked, d.close)
qconnect(d.onClose, self.cleanupAndExit)
qconnect(f.add.clicked, self.onAddProfile)
qconnect(f.rename.clicked, self.onRenameProfile)
qconnect(f.delete_2.clicked, self.onRemProfile)
qconnect(f.profiles.currentRowChanged, self.onProfileRowChange)
f.statusbar.setVisible(False)
f.downgrade_button.clicked.connect(self._on_downgrade)
qconnect(f.downgrade_button.clicked, self._on_downgrade)
# enter key opens profile
QShortcut(QKeySequence("Return"), d, activated=self.onOpenProfile) # type: ignore
self.refreshProfilesList()
@ -1128,23 +1128,25 @@ title="%s" %s>%s</button>""" % (
def setupMenus(self) -> None:
m = self.form
m.actionSwitchProfile.triggered.connect(self.unloadProfileAndShowProfileManager)
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)
qconnect(
m.actionSwitchProfile.triggered, self.unloadProfileAndShowProfileManager
)
qconnect(m.actionImport.triggered, self.onImport)
qconnect(m.actionExport.triggered, self.onExport)
qconnect(m.actionExit.triggered, self.close)
qconnect(m.actionPreferences.triggered, self.onPrefs)
qconnect(m.actionAbout.triggered, self.onAbout)
qconnect(m.actionUndo.triggered, self.onUndo)
if qtminor < 11:
m.actionUndo.setShortcut(QKeySequence("Ctrl+Alt+Z"))
m.actionFullDatabaseCheck.triggered.connect(self.onCheckDB)
m.actionCheckMediaDatabase.triggered.connect(self.on_check_media_db)
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)
qconnect(m.actionFullDatabaseCheck.triggered, self.onCheckDB)
qconnect(m.actionCheckMediaDatabase.triggered, self.on_check_media_db)
qconnect(m.actionDocumentation.triggered, self.onDocumentation)
qconnect(m.actionDonate.triggered, self.onDonate)
qconnect(m.actionStudyDeck.triggered, self.onStudyDeck)
qconnect(m.actionCreateFiltered.triggered, self.onCram)
qconnect(m.actionEmptyCards.triggered, self.onEmptyCards)
qconnect(m.actionNoteTypes.triggered, self.onNoteTypes)
def updateTitleBar(self) -> None:
self.setWindowTitle("Anki")
@ -1156,9 +1158,9 @@ title="%s" %s>%s</button>""" % (
import aqt.update
self.autoUpdate = aqt.update.LatestVersionFinder(self)
self.autoUpdate.newVerAvail.connect(self.newVerAvail) # type: ignore
self.autoUpdate.newMsg.connect(self.newMsg) # type: ignore
self.autoUpdate.clockIsOff.connect(self.clockIsOff) # type: ignore
qconnect(self.autoUpdate.newVerAvail, self.newVerAvail)
qconnect(self.autoUpdate.newMsg, self.newMsg)
qconnect(self.autoUpdate.clockIsOff, self.clockIsOff)
self.autoUpdate.start()
def newVerAvail(self, ver):
@ -1360,7 +1362,7 @@ will be lost. Continue?"""
)
self.reset()
box.accepted.connect(onDelete)
qconnect(box.accepted, onDelete)
diag.show()
# Debugging
@ -1376,13 +1378,13 @@ will be lost. Continue?"""
frm.text.setFont(font)
frm.log.setFont(font)
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+return"), d)
s.activated.connect(lambda: self.onDebugRet(frm))
qconnect(s.activated, lambda: self.onDebugRet(frm))
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+return"), d)
s.activated.connect(lambda: self.onDebugPrint(frm))
qconnect(s.activated, lambda: self.onDebugPrint(frm))
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+l"), d)
s.activated.connect(frm.log.clear)
qconnect(s.activated, frm.log.clear)
s = self.debugDiagShort = QShortcut(QKeySequence("ctrl+shift+l"), d)
s.activated.connect(frm.text.clear)
qconnect(s.activated, frm.text.clear)
def addContextMenu(ev: QCloseEvent, name: str) -> None:
ev.accept()
@ -1514,7 +1516,7 @@ will be lost. Continue?"""
if isMac:
# mac users expect a minimize option
self.minimizeShortcut = QShortcut("Ctrl+M", self)
self.minimizeShortcut.activated.connect(self.onMacMinimize) # type: ignore
qconnect(self.minimizeShortcut.activated, self.onMacMinimize)
self.hideMenuAccels = True
self.maybeHideAccelerators()
self.hideStatusTips()
@ -1546,7 +1548,7 @@ will be lost. Continue?"""
##########################################################################
def setupAppMsg(self) -> None:
self.app.appMsg.connect(self.onAppMsg)
qconnect(self.app.appMsg, self.onAppMsg)
def onAppMsg(self, buf: str) -> Optional[QTimer]:
is_addon = self._isAddon(buf)
@ -1606,7 +1608,7 @@ Please ensure a profile is open and Anki is not busy, then try again."""
# ensure gc runs in main thread
def setupDialogGC(self, obj: Any) -> None:
obj.finished.connect(lambda: self.gcWindow(obj))
qconnect(obj.finished, lambda: self.gcWindow(obj))
def gcWindow(self, obj: Any) -> None:
obj.deleteLater()

14
qt/aqt/mediacheck.py
View file

@ -6,7 +6,7 @@ from __future__ import annotations
import itertools
import time
from concurrent.futures import Future
from typing import Iterable, List, Optional, TypeVar
from typing import Iterable, List, Optional, Sequence, TypeVar
import aqt
from anki import hooks
@ -84,27 +84,27 @@ class MediaChecker:
b = QPushButton(tr(TR.MEDIA_CHECK_DELETE_UNUSED))
b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_trash_files(output.unused)) # type: ignore
qconnect(b.clicked, lambda c: self._on_trash_files(output.unused))
if output.missing:
if any(map(lambda x: x.startswith("latex-"), output.missing)):
b = QPushButton(tr(TR.MEDIA_CHECK_RENDER_LATEX))
b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(self._on_render_latex) # type: ignore
qconnect(b.clicked, self._on_render_latex)
if output.have_trash:
b = QPushButton(tr(TR.MEDIA_CHECK_EMPTY_TRASH))
b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_empty_trash()) # type: ignore
qconnect(b.clicked, lambda c: self._on_empty_trash())
b = QPushButton(tr(TR.MEDIA_CHECK_RESTORE_TRASH))
b.setAutoDefault(False)
box.addButton(b, QDialogButtonBox.RejectRole)
b.clicked.connect(lambda c: self._on_restore_trash()) # type: ignore
qconnect(b.clicked, lambda c: self._on_restore_trash())
box.rejected.connect(diag.reject) # type: ignore
qconnect(box.rejected, diag.reject)
diag.setMinimumHeight(400)
diag.setMinimumWidth(500)
restoreGeom(diag, "checkmediadb")
@ -137,7 +137,7 @@ class MediaChecker:
self.mw.progress.update(tr(TR.MEDIA_CHECK_CHECKED, count=count))
return True
def _on_trash_files(self, fnames: List[str]):
def _on_trash_files(self, fnames: Sequence[str]):
if not askUser(tr(TR.MEDIA_CHECK_DELETE_UNUSED_CONFIRM)):
return

4
qt/aqt/mediasync.py
View file

@ -22,7 +22,7 @@ from anki.rsbackend import (
from anki.types import assert_impossible
from anki.utils import intTime
from aqt import gui_hooks
from aqt.qt import QDialog, QDialogButtonBox, QPushButton
from aqt.qt import QDialog, QDialogButtonBox, QPushButton, qconnect
from aqt.utils import showWarning, tr
LogEntry = Union[MediaSyncProgress, str]
@ -167,7 +167,7 @@ class MediaSyncDialog(QDialog):
self.form.setupUi(self)
self.setWindowTitle(tr(TR.SYNC_MEDIA_LOG_TITLE))
self.abort_button = QPushButton(tr(TR.SYNC_ABORT_BUTTON))
self.abort_button.clicked.connect(self._on_abort) # type: ignore
qconnect(self.abort_button.clicked, self._on_abort)
self.abort_button.setAutoDefault(False)
self.form.buttonBox.addButton(self.abort_button, QDialogButtonBox.ActionRole)
self.abort_button.setHidden(not self._syncer.is_syncing())

2
qt/aqt/modelchooser.py
View file

@ -32,7 +32,7 @@ class ModelChooser(QHBoxLayout):
s = QShortcut(QKeySequence("Ctrl+N"), self.widget, activated=self.onModelChange)
self.models.setAutoDefault(False)
self.addWidget(self.models)
self.models.clicked.connect(self.onModelChange)
qconnect(self.models.clicked, self.onModelChange)
# layout
sizePolicy = QSizePolicy(QSizePolicy.Policy(7), QSizePolicy.Policy(0))
self.models.setSizePolicy(sizePolicy)

35
qt/aqt/models.py
View file

@ -3,6 +3,7 @@
import collections
import re
from operator import itemgetter
from typing import Optional
import aqt.clayout
from anki import stdmodels
@ -32,7 +33,7 @@ class Models(QDialog):
self.mw.checkpoint(_("Note Types"))
self.form = aqt.forms.models.Ui_Dialog()
self.form.setupUi(self)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("notetypes"))
qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("notetypes"))
self.setupModels()
restoreGeom(self, "models")
self.exec_()
@ -46,20 +47,20 @@ class Models(QDialog):
box = f.buttonBox
t = QDialogButtonBox.ActionRole
b = box.addButton(_("Add"), t)
b.clicked.connect(self.onAdd)
qconnect(b.clicked, self.onAdd)
b = box.addButton(_("Rename"), t)
b.clicked.connect(self.onRename)
qconnect(b.clicked, self.onRename)
b = box.addButton(_("Delete"), t)
b.clicked.connect(self.onDelete)
qconnect(b.clicked, self.onDelete)
if self.fromMain:
b = box.addButton(_("Fields..."), t)
b.clicked.connect(self.onFields)
qconnect(b.clicked, self.onFields)
b = box.addButton(_("Cards..."), t)
b.clicked.connect(self.onCards)
qconnect(b.clicked, self.onCards)
b = box.addButton(_("Options..."), t)
b.clicked.connect(self.onAdvanced)
f.modelsList.currentRowChanged.connect(self.modelChanged)
f.modelsList.itemDoubleClicked.connect(self.onRename)
qconnect(b.clicked, self.onAdvanced)
qconnect(f.modelsList.currentRowChanged, self.modelChanged)
qconnect(f.modelsList.itemDoubleClicked, self.onRename)
self.updateModelsList()
f.modelsList.setCurrentRow(0)
maybeHideClose(box)
@ -123,7 +124,7 @@ class Models(QDialog):
frm.latexHeader.setText(self.model["latexPre"])
frm.latexFooter.setText(self.model["latexPost"])
d.setWindowTitle(_("Options for %s") % self.model["name"])
frm.buttonBox.helpRequested.connect(lambda: openHelp("latex"))
qconnect(frm.buttonBox.helpRequested, lambda: openHelp("latex"))
restoreGeom(d, "modelopts")
gui_hooks.models_advanced_will_show(d)
d.exec_()
@ -180,19 +181,19 @@ class Models(QDialog):
class AddModel(QDialog):
def __init__(self, mw, parent=None):
self.parent = parent or mw
def __init__(self, mw: AnkiQt, parent: Optional[QWidget] = None):
self.parent_ = parent or mw
self.mw = mw
self.col = mw.col
QDialog.__init__(self, self.parent, Qt.Window)
QDialog.__init__(self, self.parent_, Qt.Window)
self.model = None
self.dialog = aqt.forms.addmodel.Ui_Dialog()
self.dialog.setupUi(self)
# standard models
self.models = []
for (name, func) in stdmodels.models:
if isinstance(name, collections.Callable):
name = name()
if isinstance(name, collections.Callable): # type: ignore
name = name() # type: ignore
item = QListWidgetItem(_("Add: %s") % name)
self.dialog.models.addItem(item)
self.models.append((True, func))
@ -204,9 +205,9 @@ class AddModel(QDialog):
self.dialog.models.setCurrentRow(0)
# the list widget will swallow the enter key
s = QShortcut(QKeySequence("Return"), self)
s.activated.connect(self.accept)
qconnect(s.activated, self.accept)
# help
self.dialog.buttonBox.helpRequested.connect(self.onHelp)
qconnect(self.dialog.buttonBox.helpRequested, self.onHelp)
def get(self):
self.exec_()

3
qt/aqt/mpv.py
View file

@ -42,6 +42,7 @@ from queue import Empty, Full, Queue
from typing import Dict, Optional
from anki.utils import isWin
from aqt import qconnect
class MPVError(Exception):
@ -180,7 +181,7 @@ class MPVBase:
# unix socket
try:
self._sock = socket.socket(socket.AF_UNIX)
self._sock.connect(self._sock_filename)
qconnect(self._sock, self._sock_filename)
except (FileNotFoundError, ConnectionRefusedError):
self._sock.close()
continue

8
qt/aqt/preferences.py
View file

@ -22,7 +22,7 @@ class Preferences(QDialog):
self.form.setupUi(self)
self.form.buttonBox.button(QDialogButtonBox.Help).setAutoDefault(False)
self.form.buttonBox.button(QDialogButtonBox.Close).setAutoDefault(False)
self.form.buttonBox.helpRequested.connect(lambda: openHelp("profileprefs"))
qconnect(self.form.buttonBox.helpRequested, lambda: openHelp("profileprefs"))
self.silentlyClose = True
self.setupLang()
self.setupCollection()
@ -54,7 +54,7 @@ class Preferences(QDialog):
f = self.form
f.lang.addItems([x[0] for x in anki.lang.langs])
f.lang.setCurrentIndex(self.langIdx())
f.lang.currentIndexChanged.connect(self.onLangIdxChanged)
qconnect(f.lang.currentIndexChanged, self.onLangIdxChanged)
def langIdx(self):
codes = [x[1] for x in anki.lang.langs]
@ -193,14 +193,14 @@ class Preferences(QDialog):
def setupNetwork(self):
self.form.media_log.setText(tr(TR.SYNC_MEDIA_LOG_BUTTON))
self.form.media_log.clicked.connect(self.on_media_log)
qconnect(self.form.media_log.clicked, self.on_media_log)
self.form.syncOnProgramOpen.setChecked(self.prof["autoSync"])
self.form.syncMedia.setChecked(self.prof["syncMedia"])
if not self.prof["syncKey"]:
self._hideAuth()
else:
self.form.syncUser.setText(self.prof.get("syncUser", ""))
self.form.syncDeauth.clicked.connect(self.onSyncDeauth)
qconnect(self.form.syncDeauth.clicked, self.onSyncDeauth)
def on_media_log(self):
self.mw.media_syncer.show_sync_log()

4
qt/aqt/profiles.py
View file

@ -416,8 +416,8 @@ create table if not exists profiles
d = self.langDiag = NoCloseDiag()
f = self.langForm = aqt.forms.setlang.Ui_Dialog()
f.setupUi(d)
d.accepted.connect(self._onLangSelected)
d.rejected.connect(lambda: True)
qconnect(d.accepted, self._onLangSelected)
qconnect(d.rejected, lambda: True)
# default to the system language
try:
(lang, enc) = locale.getdefaultlocale()

12
qt/aqt/progress.py
View file

@ -45,7 +45,7 @@ class ProgressManager:
t = QTimer(self.mw)
if not repeat:
t.setSingleShot(True)
t.timeout.connect(handler)
qconnect(t.timeout, handler)
t.start(ms)
return t
@ -74,7 +74,7 @@ class ProgressManager:
self._win.setWindowModality(Qt.ApplicationModal)
self._win.setMinimumWidth(300)
self._setBusy()
self._shown = False
self._shown = 0
self._counter = min
self._min = min
self._max = max
@ -84,10 +84,10 @@ class ProgressManager:
self._show_timer = QTimer(self.mw)
self._show_timer.setSingleShot(True)
self._show_timer.start(600)
self._show_timer.timeout.connect(self._on_show_timer) # type: ignore
qconnect(self._show_timer.timeout, self._on_show_timer)
return self._win
def update(self, label=None, value=None, process=True, maybeShow=True):
def update(self, label=None, value=None, process=True, maybeShow=True) -> None:
# print self._min, self._counter, self._max, label, time.time() - self._lastTime
if not self.mw.inMainThread():
print("progress.update() called on wrong thread")
@ -141,7 +141,7 @@ class ProgressManager:
self._shown = time.time()
self._win.show()
def _closeWin(self):
def _closeWin(self) -> None:
if self._shown:
while True:
# give the window system a second to present
@ -154,7 +154,7 @@ class ProgressManager:
self.app.processEvents(QEventLoop.ExcludeUserInputEvents)
self._win.cancel()
self._win = None
self._shown = False
self._shown = 0
def _setBusy(self):
self.mw.app.setOverrideCursor(QCursor(Qt.WaitCursor))

4
qt/aqt/qt.py
View file

@ -7,7 +7,7 @@
import os
import sys
import traceback
from typing import Callable
from typing import Callable, Union
from PyQt5.Qt import * # type: ignore
from PyQt5.QtCore import *
@ -55,6 +55,6 @@ if qtmajor != 5 or qtminor < 9 or qtminor == 10:
raise Exception("Anki does not support your Qt version.")
def qconnect(signal: Callable, func: Callable) -> None:
def qconnect(signal: Union[Callable, pyqtSignal], func: Callable) -> None:
"Helper to work around type checking not working with signal.connect(func)."
signal.connect(func) # type: ignore

2
qt/aqt/reviewer.py
View file

@ -757,7 +757,7 @@ time = %(time)d;
if opts.get("checked"):
a.setCheckable(True)
a.setChecked(True)
a.triggered.connect(func)
qconnect(a.triggered, func)
def onOptions(self) -> None:
self.mw.onDeckConf(self.mw.col.decks.get(self.card.odid or self.card.did))

12
qt/aqt/stats.py
View file

@ -38,14 +38,14 @@ class DeckStats(QDialog):
f.setupUi(self)
restoreGeom(self, self.name)
b = f.buttonBox.addButton(_("Save PDF"), QDialogButtonBox.ActionRole)
b.clicked.connect(self.saveImage)
qconnect(b.clicked, self.saveImage)
b.setAutoDefault(False)
f.groups.clicked.connect(lambda: self.changeScope("deck"))
qconnect(f.groups.clicked, lambda: self.changeScope("deck"))
f.groups.setShortcut("g")
f.all.clicked.connect(lambda: self.changeScope("collection"))
f.month.clicked.connect(lambda: self.changePeriod(0))
f.year.clicked.connect(lambda: self.changePeriod(1))
f.life.clicked.connect(lambda: self.changePeriod(2))
qconnect(f.all.clicked, lambda: self.changeScope("collection"))
qconnect(f.month.clicked, lambda: self.changePeriod(0))
qconnect(f.year.clicked, lambda: self.changePeriod(1))
qconnect(f.life.clicked, lambda: self.changePeriod(2))
maybeHideClose(self.form.buttonBox)
addCloseShortcut(self)
self.show()

8
qt/aqt/studydeck.py
View file

@ -48,7 +48,7 @@ class StudyDeck(QDialog):
b.setShortcut(QKeySequence("Ctrl+N"))
b.setToolTip(shortcut(_("Add New Deck (Ctrl+N)")))
self.form.buttonBox.addButton(b, QDialogButtonBox.ActionRole)
b.clicked.connect(self.onAddDeck)
qconnect(b.clicked, self.onAddDeck)
if title:
self.setWindowTitle(title)
if not names:
@ -66,9 +66,9 @@ class StudyDeck(QDialog):
accept or _("Study"), QDialogButtonBox.AcceptRole
)
self.setWindowModality(Qt.WindowModal)
self.form.buttonBox.helpRequested.connect(lambda: openHelp(help))
self.form.filter.textEdited.connect(self.redraw)
self.form.list.itemDoubleClicked.connect(self.accept)
qconnect(self.form.buttonBox.helpRequested, lambda: openHelp(help))
qconnect(self.form.filter.textEdited, self.redraw)
qconnect(self.form.list.itemDoubleClicked, self.accept)
self.show()
# redraw after show so position at center correct
self.redraw("", current)

8
qt/aqt/sync.py
View file

@ -44,8 +44,8 @@ class SyncManager(QObject):
auth=auth,
hostNum=self.pm.profile.get("hostNum"),
)
t._event.connect(self.onEvent)
t.progress_event.connect(self.on_progress)
qconnect(t._event, self.onEvent)
qconnect(t.progress_event, self.on_progress)
self.label = _("Connecting...")
prog = self.mw.progress.start(immediate=True, label=self.label)
self.sentBytes = self.recvBytes = 0
@ -268,8 +268,8 @@ enter your details below."""
vbox.addLayout(g)
bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bb.button(QDialogButtonBox.Ok).setAutoDefault(True)
bb.accepted.connect(d.accept)
bb.rejected.connect(d.reject)
qconnect(bb.accepted, d.accept)
qconnect(bb.rejected, d.reject)
vbox.addWidget(bb)
d.setLayout(vbox)
d.show()

44
qt/aqt/tagedit.py
View file

@ -18,12 +18,12 @@ class TagEdit(QLineEdit):
self.model = QStringListModel()
self.type = type
if type == 0:
self.completer = TagCompleter(self.model, parent, self)
self.completer_ = TagCompleter(self.model, parent, self)
else:
self.completer = QCompleter(self.model, parent)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.setCompleter(self.completer)
self.completer_ = QCompleter(self.model, parent)
self.completer_.setCompletionMode(QCompleter.PopupCompletion)
self.completer_.setCaseSensitivity(Qt.CaseInsensitive)
self.setCompleter(self.completer_)
def setCol(self, col):
"Set the current col, updating list of available tags."
@ -40,26 +40,26 @@ class TagEdit(QLineEdit):
def keyPressEvent(self, evt):
if evt.key() in (Qt.Key_Up, Qt.Key_Down):
# show completer on arrow key up/down
if not self.completer.popup().isVisible():
if not self.completer_.popup().isVisible():
self.showCompleter()
return
if evt.key() == Qt.Key_Tab and evt.modifiers() & Qt.ControlModifier:
# select next completion
if not self.completer.popup().isVisible():
if not self.completer_.popup().isVisible():
self.showCompleter()
index = self.completer.currentIndex()
self.completer.popup().setCurrentIndex(index)
index = self.completer_.currentIndex()
self.completer_.popup().setCurrentIndex(index)
cur_row = index.row()
if not self.completer.setCurrentRow(cur_row + 1):
self.completer.setCurrentRow(0)
if not self.completer_.setCurrentRow(cur_row + 1):
self.completer_.setCurrentRow(0)
return
if evt.key() in (Qt.Key_Enter, Qt.Key_Return):
# apply first completion if no suggestion selected
selected_row = self.completer.popup().currentIndex().row()
selected_row = self.completer_.popup().currentIndex().row()
if selected_row == -1:
self.completer.setCurrentRow(0)
index = self.completer.currentIndex()
self.completer.popup().setCurrentIndex(index)
self.completer_.setCurrentRow(0)
index = self.completer_.currentIndex()
self.completer_.popup().setCurrentIndex(index)
self.hideCompleter()
QWidget.keyPressEvent(self, evt)
return
@ -80,18 +80,18 @@ class TagEdit(QLineEdit):
gui_hooks.tag_editor_did_process_key(self, evt)
def showCompleter(self):
self.completer.setCompletionPrefix(self.text())
self.completer.complete()
self.completer_.setCompletionPrefix(self.text())
self.completer_.complete()
def focusOutEvent(self, evt):
def focusOutEvent(self, evt) -> None:
QLineEdit.focusOutEvent(self, evt)
self.lostFocus.emit()
self.completer.popup().hide()
self.lostFocus.emit() # type: ignore
self.completer_.popup().hide()
def hideCompleter(self):
if sip.isdeleted(self.completer):
if sip.isdeleted(self.completer_):
return
self.completer.popup().hide()
self.completer_.popup().hide()
class TagCompleter(QCompleter):

4
qt/aqt/taglimit.py
View file

@ -17,11 +17,11 @@ class TagLimit(QDialog):
s = QShortcut(
QKeySequence("ctrl+d"), self.dialog.activeList, context=Qt.WidgetShortcut
)
s.activated.connect(self.dialog.activeList.clearSelection)
qconnect(s.activated, self.dialog.activeList.clearSelection)
s = QShortcut(
QKeySequence("ctrl+d"), self.dialog.inactiveList, context=Qt.WidgetShortcut
)
s.activated.connect(self.dialog.inactiveList.clearSelection)
qconnect(s.activated, self.dialog.inactiveList.clearSelection)
self.rebuildTagList()
restoreGeom(self, "tagLimit")
self.exec_()

4
qt/aqt/taskman.py
View file

@ -12,6 +12,8 @@ from typing import Any, Callable, Dict, List, Optional
from PyQt5.QtCore import QObject, pyqtSignal
from aqt.qt import qconnect
Closure = Callable[[], None]
@ -23,7 +25,7 @@ class TaskManager(QObject):
self._executor = ThreadPoolExecutor()
self._closures: List[Closure] = []
self._closures_lock = Lock()
self._closures_pending.connect(self._on_closures_pending) # type: ignore
qconnect(self._closures_pending, self._on_closures_pending)
def run_on_main(self, closure: Closure):
"Run the provided closure on the main thread."

22
qt/aqt/utils.py
View file

@ -100,7 +100,7 @@ def showInfo(
b.setDefault(True)
if help:
b = mb.addButton(QMessageBox.Help)
b.clicked.connect(lambda: openHelp(help))
qconnect(b.clicked, lambda: openHelp(help))
b.setAutoDefault(False)
return mb.exec_()
@ -137,7 +137,7 @@ def showText(
QApplication.clipboard().setText(text.toPlainText())
btn = QPushButton(_("Copy to Clipboard"))
btn.clicked.connect(onCopy)
qconnect(btn.clicked, onCopy)
box.addButton(btn, QDialogButtonBox.ActionRole)
def onReject():
@ -145,13 +145,13 @@ def showText(
saveGeom(diag, geomKey)
QDialog.reject(diag)
box.rejected.connect(onReject)
qconnect(box.rejected, onReject)
def onFinish():
if geomKey:
saveGeom(diag, geomKey)
box.accepted.connect(onFinish)
qconnect(box.accepted, onFinish)
diag.setMinimumHeight(minHeight)
diag.setMinimumWidth(minWidth)
if geomKey:
@ -257,10 +257,10 @@ class GetTextDialog(QDialog):
b = QDialogButtonBox(buts)
v.addWidget(b)
self.setLayout(v)
b.button(QDialogButtonBox.Ok).clicked.connect(self.accept)
b.button(QDialogButtonBox.Cancel).clicked.connect(self.reject)
qconnect(b.button(QDialogButtonBox.Ok).clicked, self.accept)
qconnect(b.button(QDialogButtonBox.Cancel).clicked, self.reject)
if help:
b.button(QDialogButtonBox.Help).clicked.connect(self.helpRequested)
qconnect(b.button(QDialogButtonBox.Help).clicked, self.helpRequested)
def accept(self):
return QDialog.accept(self)
@ -319,7 +319,7 @@ def chooseList(prompt, choices, startrow=0, parent=None):
c.setCurrentRow(startrow)
l.addWidget(c)
bb = QDialogButtonBox(QDialogButtonBox.Ok)
bb.accepted.connect(d.accept)
qconnect(bb.accepted, d.accept)
l.addWidget(bb)
d.exec_()
return c.currentRow()
@ -366,7 +366,7 @@ def getFile(parent, title, cb, filter="*.*", dir=None, key=None, multi=False):
cb(result)
ret.append(result)
d.accepted.connect(accept)
qconnect(d.accepted, accept)
if key:
restoreState(d, key)
d.exec_()
@ -520,7 +520,7 @@ def addCloseShortcut(widg):
if not isMac:
return
widg._closeShortcut = QShortcut(QKeySequence("Ctrl+W"), widg)
widg._closeShortcut.activated.connect(widg.reject)
qconnect(widg._closeShortcut.activated, widg.reject)
def downArrow():
@ -680,7 +680,7 @@ class MenuItem:
def renderTo(self, qmenu):
a = qmenu.addAction(self.title)
a.triggered.connect(self.func)
qconnect(a.triggered, self.func)
def qtMenuShortcutWorkaround(qmenu):

2
qt/aqt/webview.py
View file

@ -268,7 +268,7 @@ class AnkiWebView(QWebEngineView): # type: ignore
def contextMenuEvent(self, evt) -> None:
m = QMenu(self)
a = m.addAction(_("Copy"))
a.triggered.connect(self.onCopy) # type: ignore
qconnect(a.triggered, self.onCopy)
gui_hooks.webview_will_show_context_menu(self, m)
m.popup(QCursor.pos())

5
qt/mypy.ini
View file

@ -6,7 +6,12 @@ show_error_codes = true
disallow_untyped_decorators = True
warn_redundant_casts = True
warn_unused_configs = True
#check_untyped_defs = true
[mypy-aqt.forms.*]
check_untyped_defs=false
[mypy-aqt.mpv]
ignore_errors=true
[mypy-win32file]
ignore_missing_imports = True
[mypy-win32pipe]