GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-12-20 10:22:57 -05:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

more tweaks for readability/consistency

Browse source
This commit is contained in:
Damien Elmes 2020-01-15 17:45:35 +10:00
parent 237c0791f8
commit b09e7e8247
20 changed files with 344 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
pylib/anki/collection.py
View file

@ -372,7 +372,7 @@ crt=?, mod=?, scm=?, dty=?, usn=?, ls=?, conf=?""",
strids = ids2str(ids) strids = ids2str(ids)
# we need to log these independently of cards, as one side may have # we need to log these independently of cards, as one side may have
# more card templates # more card templates
hooks.notes_will_delete(self, ids) hooks.notes_will_be_deleted(self, ids)
self._logRem(ids, REM_NOTE) self._logRem(ids, REM_NOTE)
self.db.execute("delete from notes where id in %s" % strids) self.db.execute("delete from notes where id in %s" % strids)
@ -668,9 +668,7 @@ where c.nid = n.id and c.id in %s group by nid"""
fields = runFilter("mungeFields", fields, model, data, self) fields = runFilter("mungeFields", fields, model, data, self)
# allow add-ons to modify the available fields & templates # allow add-ons to modify the available fields & templates
(qfmt, afmt) = hooks.card_template_will_render( (qfmt, afmt) = hooks.card_will_render((qfmt, afmt), fields, model, data)
(qfmt, afmt), fields, model, data
)
# render fields # render fields
qatext = render_card(self, qfmt, afmt, fields, card_ord) qatext = render_card(self, qfmt, afmt, fields, card_ord)
@ -678,7 +676,7 @@ where c.nid = n.id and c.id in %s group by nid"""
# allow add-ons to modify the generated result # allow add-ons to modify the generated result
for type in "q", "a": for type in "q", "a":
ret[type] = hooks.card_template_did_render( ret[type] = hooks.card_did_render(
ret[type], type, fields, model, data, self ret[type], type, fields, model, data, self
) )

2
pylib/anki/decks.py
View file

@ -165,7 +165,7 @@ class DeckManager:
self.decks[str(id)] = g self.decks[str(id)] = g
self.save(g) self.save(g)
self.maybeAddToActive() self.maybeAddToActive()
hooks.deck_did_create(g) hooks.deck_added(g)
return int(id) return int(id)
def rem(self, did: int, cardsToo: bool = False, childrenToo: bool = True) -> None: def rem(self, did: int, cardsToo: bool = False, childrenToo: bool = True) -> None:

2
pylib/anki/exporting.py
View file

@ -417,5 +417,5 @@ def exporters() -> List[Tuple[str, Any]]:
id(TextNoteExporter), id(TextNoteExporter),
id(TextCardExporter), id(TextCardExporter),
] ]
hooks.exporters_list_did_create(exps) hooks.exporters_list_created(exps)
return exps return exps

2
pylib/anki/find.py
View file

@ -40,7 +40,7 @@ class Finder:
flag=self._findFlag, flag=self._findFlag,
) )
self.search["is"] = self._findCardState self.search["is"] = self._findCardState
hooks.search_terms_did_prepare(self.search) hooks.search_terms_prepared(self.search)
def findCards(self, query, order=False) -> Any: def findCards(self, query, order=False) -> Any:
"Return a list of card ids for QUERY." "Return a list of card ids for QUERY."

84
pylib/anki/hooks.py
View file

@ -54,31 +54,7 @@ class _CardDidLeechHook:
card_did_leech = _CardDidLeechHook() card_did_leech = _CardDidLeechHook()
class _CardOdueWasInvalidHook: class _CardDidRenderFilter:
_hooks: List[Callable[[], None]] = []
def append(self, cb: Callable[[], None]) -> None:
"""()"""
self._hooks.append(cb)
def remove(self, cb: Callable[[], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self) -> None:
for hook in self._hooks:
try:
hook()
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
card_odue_was_invalid = _CardOdueWasInvalidHook()
class _CardTemplateDidRenderFilter:
"""Can modify the resulting text after rendering completes.""" """Can modify the resulting text after rendering completes."""
_hooks: List[ _hooks: List[
@ -150,10 +126,34 @@ class _CardTemplateDidRenderFilter:
return text return text
card_template_did_render = _CardTemplateDidRenderFilter() card_did_render = _CardDidRenderFilter()
class _CardTemplateWillRenderFilter: class _CardOdueWasInvalidHook:
_hooks: List[Callable[[], None]] = []
def append(self, cb: Callable[[], None]) -> None:
"""()"""
self._hooks.append(cb)
def remove(self, cb: Callable[[], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self) -> None:
for hook in self._hooks:
try:
hook()
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
card_odue_was_invalid = _CardOdueWasInvalidHook()
class _CardWillRenderFilter:
"""Can modify the available fields and question/answer templates prior to rendering.""" """Can modify the available fields and question/answer templates prior to rendering."""
_hooks: List[ _hooks: List[
@ -197,10 +197,10 @@ class _CardTemplateWillRenderFilter:
return templates return templates
card_template_will_render = _CardTemplateWillRenderFilter() card_will_render = _CardWillRenderFilter()
class _DeckDidCreateHook: class _DeckAddedHook:
_hooks: List[Callable[[Dict[str, Any]], None]] = [] _hooks: List[Callable[[Dict[str, Any]], None]] = []
def append(self, cb: Callable[[Dict[str, Any]], None]) -> None: def append(self, cb: Callable[[Dict[str, Any]], None]) -> None:
@ -223,10 +223,10 @@ class _DeckDidCreateHook:
runHook("newDeck") runHook("newDeck")
deck_did_create = _DeckDidCreateHook() deck_added = _DeckAddedHook()
class _ExportersListDidCreateHook: class _ExportersListCreatedHook:
_hooks: List[Callable[[List[Tuple[str, Any]]], None]] = [] _hooks: List[Callable[[List[Tuple[str, Any]]], None]] = []
def append(self, cb: Callable[[List[Tuple[str, Any]]], None]) -> None: def append(self, cb: Callable[[List[Tuple[str, Any]]], None]) -> None:
@ -249,10 +249,10 @@ class _ExportersListDidCreateHook:
runHook("exportersList", exporters) runHook("exportersList", exporters)
exporters_list_did_create = _ExportersListDidCreateHook() exporters_list_created = _ExportersListCreatedHook()
class _FieldWillBeFilteredFilter: class _FieldFilterFilter:
_hooks: List[Callable[[str, str, str, Dict[str, str]], str]] = [] _hooks: List[Callable[[str, str, str, Dict[str, str]], str]] = []
def append(self, cb: Callable[[str, str, str, Dict[str, str]], str]) -> None: def append(self, cb: Callable[[str, str, str, Dict[str, str]], str]) -> None:
@ -276,7 +276,7 @@ class _FieldWillBeFilteredFilter:
return field_text return field_text
field_will_be_filtered = _FieldWillBeFilteredFilter() field_filter = _FieldFilterFilter()
class _HttpDataDidReceiveHook: class _HttpDataDidReceiveHook:
@ -351,7 +351,7 @@ class _MediaFilesDidExportHook:
media_files_did_export = _MediaFilesDidExportHook() media_files_did_export = _MediaFilesDidExportHook()
class _NoteTypeDidCreateHook: class _NoteTypeAddedHook:
_hooks: List[Callable[[Dict[str, Any]], None]] = [] _hooks: List[Callable[[Dict[str, Any]], None]] = []
def append(self, cb: Callable[[Dict[str, Any]], None]) -> None: def append(self, cb: Callable[[Dict[str, Any]], None]) -> None:
@ -374,10 +374,10 @@ class _NoteTypeDidCreateHook:
runHook("newModel") runHook("newModel")
note_type_did_create = _NoteTypeDidCreateHook() note_type_added = _NoteTypeAddedHook()
class _NotesWillDeleteHook: class _NotesWillBeDeletedHook:
_hooks: List[Callable[["anki.storage._Collection", List[int]], None]] = [] _hooks: List[Callable[["anki.storage._Collection", List[int]], None]] = []
def append( def append(
@ -404,7 +404,7 @@ class _NotesWillDeleteHook:
runHook("remNotes", col, ids) runHook("remNotes", col, ids)
notes_will_delete = _NotesWillDeleteHook() notes_will_be_deleted = _NotesWillBeDeletedHook()
class _SchemaWillChangeFilter: class _SchemaWillChangeFilter:
@ -432,7 +432,7 @@ class _SchemaWillChangeFilter:
schema_will_change = _SchemaWillChangeFilter() schema_will_change = _SchemaWillChangeFilter()
class _SearchTermsDidPrepareHook: class _SearchTermsPreparedHook:
_hooks: List[Callable[[Dict[str, Callable]], None]] = [] _hooks: List[Callable[[Dict[str, Callable]], None]] = []
def append(self, cb: Callable[[Dict[str, Callable]], None]) -> None: def append(self, cb: Callable[[Dict[str, Callable]], None]) -> None:
@ -455,7 +455,7 @@ class _SearchTermsDidPrepareHook:
runHook("search", searches) runHook("search", searches)
search_terms_did_prepare = _SearchTermsDidPrepareHook() search_terms_prepared = _SearchTermsPreparedHook()
class _SyncProgressDidChangeHook: class _SyncProgressDidChangeHook:
@ -510,7 +510,7 @@ class _SyncStageDidChangeHook:
sync_stage_did_change = _SyncStageDidChangeHook() sync_stage_did_change = _SyncStageDidChangeHook()
class _TagDidCreateHook: class _TagAddedHook:
_hooks: List[Callable[[str], None]] = [] _hooks: List[Callable[[str], None]] = []
def append(self, cb: Callable[[str], None]) -> None: def append(self, cb: Callable[[str], None]) -> None:
@ -533,7 +533,7 @@ class _TagDidCreateHook:
runHook("newTag") runHook("newTag")
tag_did_create = _TagDidCreateHook() tag_added = _TagAddedHook()
# @@AUTOGEN@@ # @@AUTOGEN@@
# Legacy hook handling # Legacy hook handling

2
pylib/anki/latex.py
View file

@ -184,4 +184,4 @@ def _errMsg(type: str, texpath: str) -> Any:
# setup q/a filter - type ignored due to import cycle # setup q/a filter - type ignored due to import cycle
hooks.card_template_did_render.append(mungeQA) # type: ignore hooks.card_did_render.append(mungeQA) # type: ignore

2
pylib/anki/models.py
View file

@ -107,7 +107,7 @@ class ModelManager:
if templates: if templates:
self._syncTemplates(m) self._syncTemplates(m)
self.changed = True self.changed = True
hooks.note_type_did_create(m) hooks.note_type_added(m)
def flush(self) -> None: def flush(self) -> None:
"Flush the registry if any models were changed." "Flush the registry if any models were changed."

2
pylib/anki/tags.py
View file

@ -50,7 +50,7 @@ class TagManager:
self.tags[t] = self.col.usn() if usn is None else usn self.tags[t] = self.col.usn() if usn is None else usn
self.changed = True self.changed = True
if found: if found:
hooks.tag_did_create(t) # pylint: disable=undefined-loop-variable hooks.tag_added(t) # pylint: disable=undefined-loop-variable
def all(self) -> List: def all(self) -> List:
return list(self.tags.keys()) return list(self.tags.keys())

2
pylib/anki/template.py
View file

@ -72,7 +72,7 @@ def apply_custom_filters(
field_text = node.current_text field_text = node.current_text
for filter_name in node.filters: for filter_name in node.filters:
field_text = hooks.field_will_be_filtered( field_text = hooks.field_filter(
field_text, node.field_name, filter_name, fields field_text, node.field_name, filter_name, fields
) )
# legacy hook - the second and fifth argument are no longer used # legacy hook - the second and fifth argument are no longer used

21
pylib/tools/genhooks.py
View file

@ -21,29 +21,29 @@ hooks = [
Hook(name="card_odue_was_invalid"), Hook(name="card_odue_was_invalid"),
Hook(name="schema_will_change", args=["proceed: bool"], return_type="bool"), Hook(name="schema_will_change", args=["proceed: bool"], return_type="bool"),
Hook( Hook(
name="notes_will_delete", name="notes_will_be_deleted",
args=["col: anki.storage._Collection", "ids: List[int]"], args=["col: anki.storage._Collection", "ids: List[int]"],
legacy_hook="remNotes", legacy_hook="remNotes",
), ),
Hook( Hook(
name="deck_did_create", name="deck_added",
args=["deck: Dict[str, Any]"], args=["deck: Dict[str, Any]"],
legacy_hook="newDeck", legacy_hook="newDeck",
legacy_no_args=True, legacy_no_args=True,
), ),
Hook(name="media_files_did_export", args=["count: int"]), Hook(name="media_files_did_export", args=["count: int"]),
Hook( Hook(
name="exporters_list_did_create", name="exporters_list_created",
args=["exporters: List[Tuple[str, Any]]"], args=["exporters: List[Tuple[str, Any]]"],
legacy_hook="exportersList", legacy_hook="exportersList",
), ),
Hook( Hook(
name="search_terms_did_prepare", name="search_terms_prepared",
args=["searches: Dict[str, Callable]"], args=["searches: Dict[str, Callable]"],
legacy_hook="search", legacy_hook="search",
), ),
Hook( Hook(
name="note_type_did_create", name="note_type_added",
args=["notetype: Dict[str, Any]"], args=["notetype: Dict[str, Any]"],
legacy_hook="newModel", legacy_hook="newModel",
legacy_no_args=True, legacy_no_args=True,
@ -53,13 +53,10 @@ hooks = [
Hook(name="http_data_did_send", args=["bytes: int"]), Hook(name="http_data_did_send", args=["bytes: int"]),
Hook(name="http_data_did_receive", args=["bytes: int"]), Hook(name="http_data_did_receive", args=["bytes: int"]),
Hook( Hook(
name="tag_did_create", name="tag_added", args=["tag: str"], legacy_hook="newTag", legacy_no_args=True,
args=["tag: str"],
legacy_hook="newTag",
legacy_no_args=True,
), ),
Hook( Hook(
name="card_template_will_render", name="card_will_render",
args=[ args=[
"templates: Tuple[str, str]", "templates: Tuple[str, str]",
"fields: Dict[str, str]", "fields: Dict[str, str]",
@ -70,7 +67,7 @@ hooks = [
doc="Can modify the available fields and question/answer templates prior to rendering.", doc="Can modify the available fields and question/answer templates prior to rendering.",
), ),
Hook( Hook(
name="card_template_did_render", name="card_did_render",
args=[ args=[
"text: str", "text: str",
"side: str", "side: str",
@ -86,7 +83,7 @@ hooks = [
doc="Can modify the resulting text after rendering completes.", doc="Can modify the resulting text after rendering completes.",
), ),
Hook( Hook(
name="field_will_be_filtered", name="field_filter",
args=[ args=[
"field_text: str", "field_text: str",
"field_name: str", "field_name: str",

4
qt/aqt/addcards.py
View file

@ -156,7 +156,7 @@ class AddCards(QDialog):
else: else:
a = m.addAction(_("(Note deleted)")) a = m.addAction(_("(Note deleted)"))
a.setEnabled(False) a.setEnabled(False)
gui_hooks.add_cards_history_menu_will_show(self, m) gui_hooks.add_cards_will_show_history_menu(self, m)
m.exec_(self.historyButton.mapToGlobal(QPoint(0, 0))) m.exec_(self.historyButton.mapToGlobal(QPoint(0, 0)))
def editHistory(self, nid): def editHistory(self, nid):
@ -196,7 +196,7 @@ question on all cards."""
self.addHistory(note) self.addHistory(note)
self.mw.requireReset() self.mw.requireReset()
self.previousNote = note self.previousNote = note
gui_hooks.add_cards_note_did_add(note) gui_hooks.add_cards_did_add_note(note)
return note return note
def addCards(self): def addCards(self):

32
qt/aqt/browser.py
View file

@ -653,7 +653,7 @@ class Browser(QMainWindow):
m.addSeparator() m.addSeparator()
for act in self.form.menu_Notes.actions(): for act in self.form.menu_Notes.actions():
m.addAction(act) m.addAction(act)
gui_hooks.browser_context_menu_will_show(self, m) gui_hooks.browser_will_show_context_menu(self, m)
qtMenuShortcutWorkaround(m) qtMenuShortcutWorkaround(m)
m.exec_(QCursor.pos()) m.exec_(QCursor.pos())
@ -844,7 +844,7 @@ class Browser(QMainWindow):
self.editor.card = self.card self.editor.card = self.card
self.singleCard = True self.singleCard = True
self._updateFlagsMenu() self._updateFlagsMenu()
gui_hooks.browser_row_did_change(self) gui_hooks.browser_did_change_row(self)
self._renderPreview(True) self._renderPreview(True)
def refreshCurrentCard(self, note): def refreshCurrentCard(self, note):
@ -1716,7 +1716,9 @@ where id in %s"""
play(audio) play(audio)
txt = mungeQA(self.col, txt) txt = mungeQA(self.col, txt)
gui_hooks.card_text(txt, c, "preview" + self._previewState.capitalize()) gui_hooks.card_will_show(
txt, c, "preview" + self._previewState.capitalize()
)
self._lastPreviewState = self._previewStateAndMod() self._lastPreviewState = self._previewStateAndMod()
self._updatePreviewButtons() self._updatePreviewButtons()
self._previewWeb.eval("{}({},'{}');".format(func, json.dumps(txt), bodyclass)) self._previewWeb.eval("{}({},'{}');".format(func, json.dumps(txt), bodyclass))
@ -2020,22 +2022,22 @@ update cards set usn=?, mod=?, did=? where id in """
def setupHooks(self): def setupHooks(self):
gui_hooks.undo_state_did_change.append(self.onUndoState) gui_hooks.undo_state_did_change.append(self.onUndoState)
gui_hooks.state_did_reset.append(self.onReset) gui_hooks.state_did_reset.append(self.onReset)
gui_hooks.editor_typing_timer_did_fire.append(self.refreshCurrentCard) gui_hooks.editor_did_fire_typing_timer.append(self.refreshCurrentCard)
gui_hooks.editor_note_did_load.append(self.onLoadNote) gui_hooks.editor_did_load_note.append(self.onLoadNote)
gui_hooks.editor_field_did_lose_focus.append(self.refreshCurrentCard) gui_hooks.editor_did_unfocus_field.append(self.refreshCurrentCard)
hooks.tag_did_create.append(self.maybeRefreshSidebar) hooks.tag_added.append(self.maybeRefreshSidebar)
hooks.note_type_did_create.append(self.maybeRefreshSidebar) hooks.note_type_added.append(self.maybeRefreshSidebar)
hooks.deck_did_create.append(self.maybeRefreshSidebar) hooks.deck_added.append(self.maybeRefreshSidebar)
def teardownHooks(self): def teardownHooks(self):
gui_hooks.undo_state_did_change.remove(self.onUndoState) gui_hooks.undo_state_did_change.remove(self.onUndoState)
gui_hooks.state_did_reset.remove(self.onReset) gui_hooks.state_did_reset.remove(self.onReset)
gui_hooks.editor_typing_timer_did_fire.remove(self.refreshCurrentCard) gui_hooks.editor_did_fire_typing_timer.remove(self.refreshCurrentCard)
gui_hooks.editor_note_did_load.remove(self.onLoadNote) gui_hooks.editor_did_load_note.remove(self.onLoadNote)
gui_hooks.editor_field_did_lose_focus.remove(self.refreshCurrentCard) gui_hooks.editor_did_unfocus_field.remove(self.refreshCurrentCard)
hooks.tag_did_create.remove(self.maybeRefreshSidebar) hooks.tag_added.remove(self.maybeRefreshSidebar)
hooks.note_type_did_create.remove(self.maybeRefreshSidebar) hooks.note_type_added.remove(self.maybeRefreshSidebar)
hooks.deck_did_create.remove(self.maybeRefreshSidebar) hooks.deck_added.remove(self.maybeRefreshSidebar)
def onUndoState(self, on): def onUndoState(self, on):
self.form.actionUndo.setEnabled(on) self.form.actionUndo.setEnabled(on)

4
qt/aqt/clayout.py
View file

@ -335,10 +335,10 @@ Please create a new card type first."""
bodyclass = bodyClass(self.mw.col, c) bodyclass = bodyClass(self.mw.col, c)
q = ti(mungeQA(self.mw.col, c.q(reload=True))) q = ti(mungeQA(self.mw.col, c.q(reload=True)))
q = gui_hooks.card_text(q, c, "clayoutQuestion") q = gui_hooks.card_will_show(q, c, "clayoutQuestion")
a = ti(mungeQA(self.mw.col, c.a()), type="a") a = ti(mungeQA(self.mw.col, c.a()), type="a")
a = gui_hooks.card_text(a, c, "clayoutAnswer") a = gui_hooks.card_will_show(a, c, "clayoutAnswer")
# use _showAnswer to avoid the longer delay # use _showAnswer to avoid the longer delay
self.pform.frontWeb.eval("_showAnswer(%s,'%s');" % (json.dumps(q), bodyclass)) self.pform.frontWeb.eval("_showAnswer(%s,'%s');" % (json.dumps(q), bodyclass))

2
qt/aqt/deckbrowser.py
View file

@ -245,7 +245,7 @@ where id > ?""",
a.triggered.connect(lambda b, did=did: self._export(did)) a.triggered.connect(lambda b, did=did: self._export(did))
a = m.addAction(_("Delete")) a = m.addAction(_("Delete"))
a.triggered.connect(lambda b, did=did: self._delete(did)) a.triggered.connect(lambda b, did=did: self._delete(did))
gui_hooks.deck_browser_options_menu_will_show(m, did) gui_hooks.deck_browser_will_show_options_menu(m, did)
m.exec_(QCursor.pos()) m.exec_(QCursor.pos())
def _export(self, did): def _export(self, did):

20
qt/aqt/editor.py
View file

@ -141,7 +141,7 @@ class Editor:
self._addButton("more", "more"), self._addButton("more", "more"),
] ]
) )
gui_hooks.editor_buttons_did_init(righttopbtns, self) gui_hooks.editor_did_init_buttons(righttopbtns, self)
# legacy filter # legacy filter
righttopbtns = runFilter("setupEditorButtons", righttopbtns, self) righttopbtns = runFilter("setupEditorButtons", righttopbtns, self)
topbuts = """ topbuts = """
@ -285,7 +285,7 @@ class Editor:
("Ctrl+Shift+X", self.onHtmlEdit), ("Ctrl+Shift+X", self.onHtmlEdit),
("Ctrl+Shift+T", self.onFocusTags, True), ("Ctrl+Shift+T", self.onFocusTags, True),
] ]
gui_hooks.editor_shortcuts_did_init(cuts, self) gui_hooks.editor_did_init_shortcuts(cuts, self)
for row in cuts: for row in cuts:
if len(row) == 2: if len(row) == 2:
keys, fn = row # pylint: disable=unbalanced-tuple-unpacking keys, fn = row # pylint: disable=unbalanced-tuple-unpacking
@ -358,20 +358,20 @@ class Editor:
if type == "blur": if type == "blur":
self.currentField = None self.currentField = None
# run any filters # run any filters
if gui_hooks.editor_field_did_lose_focus(False, self.note, ord): if gui_hooks.editor_did_unfocus_field(False, self.note, ord):
# something updated the note; update it after a subsequent focus # something updated the note; update it after a subsequent focus
# event has had time to fire # event has had time to fire
self.mw.progress.timer(100, self.loadNoteKeepingFocus, False) self.mw.progress.timer(100, self.loadNoteKeepingFocus, False)
else: else:
self.checkValid() self.checkValid()
else: else:
gui_hooks.editor_typing_timer_did_fire(self.note) gui_hooks.editor_did_fire_typing_timer(self.note)
self.checkValid() self.checkValid()
# focused into field? # focused into field?
elif cmd.startswith("focus"): elif cmd.startswith("focus"):
(type, num) = cmd.split(":", 1) (type, num) = cmd.split(":", 1)
self.currentField = int(num) self.currentField = int(num)
gui_hooks.editor_field_did_gain_focus(self.note, self.currentField) gui_hooks.editor_did_focus_field(self.note, self.currentField)
elif cmd in self._links: elif cmd in self._links:
self._links[cmd](self) self._links[cmd](self)
else: else:
@ -416,7 +416,7 @@ class Editor:
self.checkValid() self.checkValid()
if focusTo is not None: if focusTo is not None:
self.web.setFocus() self.web.setFocus()
gui_hooks.editor_note_did_load(self) gui_hooks.editor_did_load_note(self)
js = "setFields(%s); setFonts(%s); focusField(%s); setNoteId(%s)" % ( js = "setFields(%s); setFonts(%s); focusField(%s); setNoteId(%s)" % (
json.dumps(data), json.dumps(data),
@ -428,7 +428,7 @@ class Editor:
def fonts(self): def fonts(self):
return [ return [
(gui_hooks.editor_font_for_field(f["font"]), f["size"], f["rtl"]) (gui_hooks.editor_will_use_font_for_field(f["font"]), f["size"], f["rtl"])
for f in self.note.model()["flds"] for f in self.note.model()["flds"]
] ]
@ -536,7 +536,7 @@ class Editor:
self.tags.setText(self.mw.col.tags.join(self.note.tags).strip()) self.tags.setText(self.mw.col.tags.join(self.note.tags).strip())
if not self.addMode: if not self.addMode:
self.note.flush() self.note.flush()
gui_hooks.editor_tags_did_update(self.note) gui_hooks.editor_did_update_tags(self.note)
def saveAddModeVars(self): def saveAddModeVars(self):
if self.addMode: if self.addMode:
@ -1111,7 +1111,7 @@ class EditorWebView(AnkiWebView):
a.triggered.connect(self.onCopy) a.triggered.connect(self.onCopy)
a = m.addAction(_("Paste")) a = m.addAction(_("Paste"))
a.triggered.connect(self.onPaste) a.triggered.connect(self.onPaste)
gui_hooks.editor_context_menu_will_show(self, m) gui_hooks.editor_will_show_context_menu(self, m)
m.popup(QCursor.pos()) m.popup(QCursor.pos())
@ -1122,4 +1122,4 @@ def fontMungeHack(font):
return re.sub(" L$", " Light", font) return re.sub(" L$", " Light", font)
gui_hooks.editor_font_for_field.append(fontMungeHack) gui_hooks.editor_will_use_font_for_field.append(fontMungeHack)

450
qt/aqt/gui_hooks.py
View file

@ -23,33 +23,7 @@ from aqt.qt import QMenu
# @@AUTOGEN@@ # @@AUTOGEN@@
class _AddCardsHistoryMenuWillShowHook: class _AddCardsDidAddNoteHook:
_hooks: List[Callable[["aqt.addcards.AddCards", QMenu], None]] = []
def append(self, cb: Callable[["aqt.addcards.AddCards", QMenu], None]) -> None:
"""(addcards: aqt.addcards.AddCards, menu: QMenu)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.addcards.AddCards", QMenu], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, addcards: aqt.addcards.AddCards, menu: QMenu) -> None:
for hook in self._hooks:
try:
hook(addcards, menu)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("AddCards.onHistory", addcards, menu)
add_cards_history_menu_will_show = _AddCardsHistoryMenuWillShowHook()
class _AddCardsNoteDidAddHook:
_hooks: List[Callable[["anki.notes.Note"], None]] = [] _hooks: List[Callable[["anki.notes.Note"], None]] = []
def append(self, cb: Callable[["anki.notes.Note"], None]) -> None: def append(self, cb: Callable[["anki.notes.Note"], None]) -> None:
@ -72,33 +46,59 @@ class _AddCardsNoteDidAddHook:
runHook("AddCards.noteAdded", note) runHook("AddCards.noteAdded", note)
add_cards_note_did_add = _AddCardsNoteDidAddHook() add_cards_did_add_note = _AddCardsDidAddNoteHook()
class _BrowserContextMenuWillShowHook: class _AddCardsWillShowHistoryMenuHook:
_hooks: List[Callable[["aqt.browser.Browser", QMenu], None]] = [] _hooks: List[Callable[["aqt.addcards.AddCards", QMenu], None]] = []
def append(self, cb: Callable[["aqt.browser.Browser", QMenu], None]) -> None: def append(self, cb: Callable[["aqt.addcards.AddCards", QMenu], None]) -> None:
"""(browser: aqt.browser.Browser, menu: QMenu)""" """(addcards: aqt.addcards.AddCards, menu: QMenu)"""
self._hooks.append(cb) self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.browser.Browser", QMenu], None]) -> None: def remove(self, cb: Callable[["aqt.addcards.AddCards", QMenu], None]) -> None:
if cb in self._hooks: if cb in self._hooks:
self._hooks.remove(cb) self._hooks.remove(cb)
def __call__(self, browser: aqt.browser.Browser, menu: QMenu) -> None: def __call__(self, addcards: aqt.addcards.AddCards, menu: QMenu) -> None:
for hook in self._hooks: for hook in self._hooks:
try: try:
hook(browser, menu) hook(addcards, menu)
except: except:
# if the hook fails, remove it # if the hook fails, remove it
self._hooks.remove(hook) self._hooks.remove(hook)
raise raise
# legacy support # legacy support
runHook("browser.onContextMenu", browser, menu) runHook("AddCards.onHistory", addcards, menu)
browser_context_menu_will_show = _BrowserContextMenuWillShowHook() add_cards_will_show_history_menu = _AddCardsWillShowHistoryMenuHook()
class _BrowserDidChangeRowHook:
_hooks: List[Callable[["aqt.browser.Browser"], None]] = []
def append(self, cb: Callable[["aqt.browser.Browser"], None]) -> None:
"""(browser: aqt.browser.Browser)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.browser.Browser"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, browser: aqt.browser.Browser) -> None:
for hook in self._hooks:
try:
hook(browser)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("browser.rowChanged", browser)
browser_did_change_row = _BrowserDidChangeRowHook()
class _BrowserMenusDidInitHook: class _BrowserMenusDidInitHook:
@ -127,33 +127,33 @@ class _BrowserMenusDidInitHook:
browser_menus_did_init = _BrowserMenusDidInitHook() browser_menus_did_init = _BrowserMenusDidInitHook()
class _BrowserRowDidChangeHook: class _BrowserWillShowContextMenuHook:
_hooks: List[Callable[["aqt.browser.Browser"], None]] = [] _hooks: List[Callable[["aqt.browser.Browser", QMenu], None]] = []
def append(self, cb: Callable[["aqt.browser.Browser"], None]) -> None: def append(self, cb: Callable[["aqt.browser.Browser", QMenu], None]) -> None:
"""(browser: aqt.browser.Browser)""" """(browser: aqt.browser.Browser, menu: QMenu)"""
self._hooks.append(cb) self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.browser.Browser"], None]) -> None: def remove(self, cb: Callable[["aqt.browser.Browser", QMenu], None]) -> None:
if cb in self._hooks: if cb in self._hooks:
self._hooks.remove(cb) self._hooks.remove(cb)
def __call__(self, browser: aqt.browser.Browser) -> None: def __call__(self, browser: aqt.browser.Browser, menu: QMenu) -> None:
for hook in self._hooks: for hook in self._hooks:
try: try:
hook(browser) hook(browser, menu)
except: except:
# if the hook fails, remove it # if the hook fails, remove it
self._hooks.remove(hook) self._hooks.remove(hook)
raise raise
# legacy support # legacy support
runHook("browser.rowChanged", browser) runHook("browser.onContextMenu", browser, menu)
browser_row_did_change = _BrowserRowDidChangeHook() browser_will_show_context_menu = _BrowserWillShowContextMenuHook()
class _CardTextFilter: class _CardWillShowFilter:
"""Can modify card text before review/preview.""" """Can modify card text before review/preview."""
_hooks: List[Callable[[str, Card, str], str]] = [] _hooks: List[Callable[[str, Card, str], str]] = []
@ -179,7 +179,7 @@ class _CardTextFilter:
return text return text
card_text = _CardTextFilter() card_will_show = _CardWillShowFilter()
class _CollectionDidLoadHook: class _CollectionDidLoadHook:
@ -234,7 +234,7 @@ class _CurrentNoteTypeDidChangeHook:
current_note_type_did_change = _CurrentNoteTypeDidChangeHook() current_note_type_did_change = _CurrentNoteTypeDidChangeHook()
class _DeckBrowserOptionsMenuWillShowHook: class _DeckBrowserWillShowOptionsMenuHook:
_hooks: List[Callable[[QMenu, int], None]] = [] _hooks: List[Callable[[QMenu, int], None]] = []
def append(self, cb: Callable[[QMenu, int], None]) -> None: def append(self, cb: Callable[[QMenu, int], None]) -> None:
@ -257,60 +257,36 @@ class _DeckBrowserOptionsMenuWillShowHook:
runHook("showDeckOptions", menu, deck_id) runHook("showDeckOptions", menu, deck_id)
deck_browser_options_menu_will_show = _DeckBrowserOptionsMenuWillShowHook() deck_browser_will_show_options_menu = _DeckBrowserWillShowOptionsMenuHook()
class _EditorButtonsDidInitHook: class _EditorDidFireTypingTimerHook:
_hooks: List[Callable[[List, "aqt.editor.Editor"], None]] = [] _hooks: List[Callable[["anki.notes.Note"], None]] = []
def append(self, cb: Callable[[List, "aqt.editor.Editor"], None]) -> None: def append(self, cb: Callable[["anki.notes.Note"], None]) -> None:
"""(buttons: List, editor: aqt.editor.Editor)""" """(note: anki.notes.Note)"""
self._hooks.append(cb) self._hooks.append(cb)
def remove(self, cb: Callable[[List, "aqt.editor.Editor"], None]) -> None: def remove(self, cb: Callable[["anki.notes.Note"], None]) -> None:
if cb in self._hooks: if cb in self._hooks:
self._hooks.remove(cb) self._hooks.remove(cb)
def __call__(self, buttons: List, editor: aqt.editor.Editor) -> None: def __call__(self, note: anki.notes.Note) -> None:
for hook in self._hooks: for hook in self._hooks:
try: try:
hook(buttons, editor) hook(note)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
editor_buttons_did_init = _EditorButtonsDidInitHook()
class _EditorContextMenuWillShowHook:
_hooks: List[Callable[["aqt.editor.EditorWebView", QMenu], None]] = []
def append(self, cb: Callable[["aqt.editor.EditorWebView", QMenu], None]) -> None:
"""(editor_webview: aqt.editor.EditorWebView, menu: QMenu)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.editor.EditorWebView", QMenu], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, editor_webview: aqt.editor.EditorWebView, menu: QMenu) -> None:
for hook in self._hooks:
try:
hook(editor_webview, menu)
except: except:
# if the hook fails, remove it # if the hook fails, remove it
self._hooks.remove(hook) self._hooks.remove(hook)
raise raise
# legacy support # legacy support
runHook("EditorWebView.contextMenuEvent", editor_webview, menu) runHook("editTimer", note)
editor_context_menu_will_show = _EditorContextMenuWillShowHook() editor_did_fire_typing_timer = _EditorDidFireTypingTimerHook()
class _EditorFieldDidGainFocusHook: class _EditorDidFocusFieldHook:
_hooks: List[Callable[["anki.notes.Note", int], None]] = [] _hooks: List[Callable[["anki.notes.Note", int], None]] = []
def append(self, cb: Callable[["anki.notes.Note", int], None]) -> None: def append(self, cb: Callable[["anki.notes.Note", int], None]) -> None:
@ -333,10 +309,86 @@ class _EditorFieldDidGainFocusHook:
runHook("editFocusGained", note, current_field_idx) runHook("editFocusGained", note, current_field_idx)
editor_field_did_gain_focus = _EditorFieldDidGainFocusHook() editor_did_focus_field = _EditorDidFocusFieldHook()
class _EditorFieldDidLoseFocusFilter: class _EditorDidInitButtonsHook:
_hooks: List[Callable[[List, "aqt.editor.Editor"], None]] = []
def append(self, cb: Callable[[List, "aqt.editor.Editor"], None]) -> None:
"""(buttons: List, editor: aqt.editor.Editor)"""
self._hooks.append(cb)
def remove(self, cb: Callable[[List, "aqt.editor.Editor"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, buttons: List, editor: aqt.editor.Editor) -> None:
for hook in self._hooks:
try:
hook(buttons, editor)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
editor_did_init_buttons = _EditorDidInitButtonsHook()
class _EditorDidInitShortcutsHook:
_hooks: List[Callable[[List[Tuple], "aqt.editor.Editor"], None]] = []
def append(self, cb: Callable[[List[Tuple], "aqt.editor.Editor"], None]) -> None:
"""(shortcuts: List[Tuple], editor: aqt.editor.Editor)"""
self._hooks.append(cb)
def remove(self, cb: Callable[[List[Tuple], "aqt.editor.Editor"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, shortcuts: List[Tuple], editor: aqt.editor.Editor) -> None:
for hook in self._hooks:
try:
hook(shortcuts, editor)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("setupEditorShortcuts", shortcuts, editor)
editor_did_init_shortcuts = _EditorDidInitShortcutsHook()
class _EditorDidLoadNoteHook:
_hooks: List[Callable[["aqt.editor.Editor"], None]] = []
def append(self, cb: Callable[["aqt.editor.Editor"], None]) -> None:
"""(editor: aqt.editor.Editor)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.editor.Editor"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, editor: aqt.editor.Editor) -> None:
for hook in self._hooks:
try:
hook(editor)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("loadNote", editor)
editor_did_load_note = _EditorDidLoadNoteHook()
class _EditorDidUnfocusFieldFilter:
_hooks: List[Callable[[bool, "anki.notes.Note", int], bool]] = [] _hooks: List[Callable[[bool, "anki.notes.Note", int], bool]] = []
def append(self, cb: Callable[[bool, "anki.notes.Note", int], bool]) -> None: def append(self, cb: Callable[[bool, "anki.notes.Note", int], bool]) -> None:
@ -362,10 +414,62 @@ class _EditorFieldDidLoseFocusFilter:
return changed return changed
editor_field_did_lose_focus = _EditorFieldDidLoseFocusFilter() editor_did_unfocus_field = _EditorDidUnfocusFieldFilter()
class _EditorFontForFieldFilter: class _EditorDidUpdateTagsHook:
_hooks: List[Callable[["anki.notes.Note"], None]] = []
def append(self, cb: Callable[["anki.notes.Note"], None]) -> None:
"""(note: anki.notes.Note)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["anki.notes.Note"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, note: anki.notes.Note) -> None:
for hook in self._hooks:
try:
hook(note)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("tagsUpdated", note)
editor_did_update_tags = _EditorDidUpdateTagsHook()
class _EditorWillShowContextMenuHook:
_hooks: List[Callable[["aqt.editor.EditorWebView", QMenu], None]] = []
def append(self, cb: Callable[["aqt.editor.EditorWebView", QMenu], None]) -> None:
"""(editor_webview: aqt.editor.EditorWebView, menu: QMenu)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.editor.EditorWebView", QMenu], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, editor_webview: aqt.editor.EditorWebView, menu: QMenu) -> None:
for hook in self._hooks:
try:
hook(editor_webview, menu)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("EditorWebView.contextMenuEvent", editor_webview, menu)
editor_will_show_context_menu = _EditorWillShowContextMenuHook()
class _EditorWillUseFontForFieldFilter:
_hooks: List[Callable[[str], str]] = [] _hooks: List[Callable[[str], str]] = []
def append(self, cb: Callable[[str], str]) -> None: def append(self, cb: Callable[[str], str]) -> None:
@ -389,111 +493,7 @@ class _EditorFontForFieldFilter:
return font return font
editor_font_for_field = _EditorFontForFieldFilter() editor_will_use_font_for_field = _EditorWillUseFontForFieldFilter()
class _EditorNoteDidLoadHook:
_hooks: List[Callable[["aqt.editor.Editor"], None]] = []
def append(self, cb: Callable[["aqt.editor.Editor"], None]) -> None:
"""(editor: aqt.editor.Editor)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.editor.Editor"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, editor: aqt.editor.Editor) -> None:
for hook in self._hooks:
try:
hook(editor)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("loadNote", editor)
editor_note_did_load = _EditorNoteDidLoadHook()
class _EditorShortcutsDidInitHook:
_hooks: List[Callable[[List[Tuple], "aqt.editor.Editor"], None]] = []
def append(self, cb: Callable[[List[Tuple], "aqt.editor.Editor"], None]) -> None:
"""(shortcuts: List[Tuple], editor: aqt.editor.Editor)"""
self._hooks.append(cb)
def remove(self, cb: Callable[[List[Tuple], "aqt.editor.Editor"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, shortcuts: List[Tuple], editor: aqt.editor.Editor) -> None:
for hook in self._hooks:
try:
hook(shortcuts, editor)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("setupEditorShortcuts", shortcuts, editor)
editor_shortcuts_did_init = _EditorShortcutsDidInitHook()
class _EditorTagsDidUpdateHook:
_hooks: List[Callable[["anki.notes.Note"], None]] = []
def append(self, cb: Callable[["anki.notes.Note"], None]) -> None:
"""(note: anki.notes.Note)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["anki.notes.Note"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, note: anki.notes.Note) -> None:
for hook in self._hooks:
try:
hook(note)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("tagsUpdated", note)
editor_tags_did_update = _EditorTagsDidUpdateHook()
class _EditorTypingTimerDidFireHook:
_hooks: List[Callable[["anki.notes.Note"], None]] = []
def append(self, cb: Callable[["anki.notes.Note"], None]) -> None:
"""(note: anki.notes.Note)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["anki.notes.Note"], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, note: anki.notes.Note) -> None:
for hook in self._hooks:
try:
hook(note)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("editTimer", note)
editor_typing_timer_did_fire = _EditorTypingTimerDidFireHook()
class _MpvDidIdleHook: class _MpvDidIdleHook:
@ -624,7 +624,7 @@ class _ReviewDidUndoHook:
review_did_undo = _ReviewDidUndoHook() review_did_undo = _ReviewDidUndoHook()
class _ReviewerAnswerDidShowHook: class _ReviewerDidShowAnswerHook:
_hooks: List[Callable[[Card], None]] = [] _hooks: List[Callable[[Card], None]] = []
def append(self, cb: Callable[[Card], None]) -> None: def append(self, cb: Callable[[Card], None]) -> None:
@ -647,36 +647,10 @@ class _ReviewerAnswerDidShowHook:
runHook("showAnswer") runHook("showAnswer")
reviewer_answer_did_show = _ReviewerAnswerDidShowHook() reviewer_did_show_answer = _ReviewerDidShowAnswerHook()
class _ReviewerContextMenuWillShowHook: class _ReviewerDidShowQuestionHook:
_hooks: List[Callable[["aqt.reviewer.Reviewer", QMenu], None]] = []
def append(self, cb: Callable[["aqt.reviewer.Reviewer", QMenu], None]) -> None:
"""(reviewer: aqt.reviewer.Reviewer, menu: QMenu)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.reviewer.Reviewer", QMenu], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, reviewer: aqt.reviewer.Reviewer, menu: QMenu) -> None:
for hook in self._hooks:
try:
hook(reviewer, menu)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("Reviewer.contextMenuEvent", reviewer, menu)
reviewer_context_menu_will_show = _ReviewerContextMenuWillShowHook()
class _ReviewerQuestionDidShowHook:
_hooks: List[Callable[[Card], None]] = [] _hooks: List[Callable[[Card], None]] = []
def append(self, cb: Callable[[Card], None]) -> None: def append(self, cb: Callable[[Card], None]) -> None:
@ -699,7 +673,7 @@ class _ReviewerQuestionDidShowHook:
runHook("showQuestion") runHook("showQuestion")
reviewer_question_did_show = _ReviewerQuestionDidShowHook() reviewer_did_show_question = _ReviewerDidShowQuestionHook()
class _ReviewerWillEndHook: class _ReviewerWillEndHook:
@ -730,6 +704,32 @@ class _ReviewerWillEndHook:
reviewer_will_end = _ReviewerWillEndHook() reviewer_will_end = _ReviewerWillEndHook()
class _ReviewerWillShowContextMenuHook:
_hooks: List[Callable[["aqt.reviewer.Reviewer", QMenu], None]] = []
def append(self, cb: Callable[["aqt.reviewer.Reviewer", QMenu], None]) -> None:
"""(reviewer: aqt.reviewer.Reviewer, menu: QMenu)"""
self._hooks.append(cb)
def remove(self, cb: Callable[["aqt.reviewer.Reviewer", QMenu], None]) -> None:
if cb in self._hooks:
self._hooks.remove(cb)
def __call__(self, reviewer: aqt.reviewer.Reviewer, menu: QMenu) -> None:
for hook in self._hooks:
try:
hook(reviewer, menu)
except:
# if the hook fails, remove it
self._hooks.remove(hook)
raise
# legacy support
runHook("Reviewer.contextMenuEvent", reviewer, menu)
reviewer_will_show_context_menu = _ReviewerWillShowContextMenuHook()
class _StateDidChangeHook: class _StateDidChangeHook:
_hooks: List[Callable[[str, str], None]] = [] _hooks: List[Callable[[str, str], None]] = []
@ -915,7 +915,7 @@ class _UndoStateDidChangeHook:
undo_state_did_change = _UndoStateDidChangeHook() undo_state_did_change = _UndoStateDidChangeHook()
class _WebviewContextMenuWillShowHook: class _WebviewWillShowContextMenuHook:
_hooks: List[Callable[["aqt.webview.AnkiWebView", QMenu], None]] = [] _hooks: List[Callable[["aqt.webview.AnkiWebView", QMenu], None]] = []
def append(self, cb: Callable[["aqt.webview.AnkiWebView", QMenu], None]) -> None: def append(self, cb: Callable[["aqt.webview.AnkiWebView", QMenu], None]) -> None:
@ -938,5 +938,5 @@ class _WebviewContextMenuWillShowHook:
runHook("AnkiWebView.contextMenuEvent", webview, menu) runHook("AnkiWebView.contextMenuEvent", webview, menu)
webview_context_menu_will_show = _WebviewContextMenuWillShowHook() webview_will_show_context_menu = _WebviewWillShowContextMenuHook()
# @@AUTOGEN@@ # @@AUTOGEN@@

2
qt/aqt/main.py
View file

@ -1154,7 +1154,7 @@ Difference to correct time: %s."""
def setupHooks(self) -> None: def setupHooks(self) -> None:
hooks.schema_will_change.append(self.onSchemaMod) hooks.schema_will_change.append(self.onSchemaMod)
hooks.notes_will_delete.append(self.onRemNotes) hooks.notes_will_be_deleted.append(self.onRemNotes)
hooks.card_odue_was_invalid.append(self.onOdueInvalid) hooks.card_odue_was_invalid.append(self.onOdueInvalid)
gui_hooks.mpv_will_play.append(self.on_mpv_will_play) gui_hooks.mpv_will_play.append(self.on_mpv_will_play)

10
qt/aqt/reviewer.py
View file

@ -187,7 +187,7 @@ The front of this card is empty. Please run Tools>Empty Cards."""
playFromText(q) playFromText(q)
# render & update bottom # render & update bottom
q = self._mungeQA(q) q = self._mungeQA(q)
q = gui_hooks.card_text(q, c, "reviewQuestion") q = gui_hooks.card_will_show(q, c, "reviewQuestion")
bodyclass = bodyClass(self.mw.col, c) bodyclass = bodyClass(self.mw.col, c)
@ -199,7 +199,7 @@ The front of this card is empty. Please run Tools>Empty Cards."""
if self.typeCorrect: if self.typeCorrect:
self.mw.web.setFocus() self.mw.web.setFocus()
# user hook # user hook
gui_hooks.reviewer_question_did_show(c) gui_hooks.reviewer_did_show_question(c)
def autoplay(self, card): def autoplay(self, card):
return self.mw.col.decks.confForDid(card.odid or card.did)["autoplay"] return self.mw.col.decks.confForDid(card.odid or card.did)["autoplay"]
@ -229,12 +229,12 @@ The front of this card is empty. Please run Tools>Empty Cards."""
if self.autoplay(c): if self.autoplay(c):
playFromText(a) playFromText(a)
a = self._mungeQA(a) a = self._mungeQA(a)
a = gui_hooks.card_text(a, c, "reviewAnswer") a = gui_hooks.card_will_show(a, c, "reviewAnswer")
# render and update bottom # render and update bottom
self.web.eval("_showAnswer(%s);" % json.dumps(a)) self.web.eval("_showAnswer(%s);" % json.dumps(a))
self._showEaseButtons() self._showEaseButtons()
# user hook # user hook
gui_hooks.reviewer_answer_did_show(c) gui_hooks.reviewer_did_show_answer(c)
# Answering a card # Answering a card
############################################################ ############################################################
@ -694,7 +694,7 @@ time = %(time)d;
m = QMenu(self.mw) m = QMenu(self.mw)
self._addMenuItems(m, opts) self._addMenuItems(m, opts)
gui_hooks.reviewer_context_menu_will_show(self, m) gui_hooks.reviewer_will_show_context_menu(self, m)
qtMenuShortcutWorkaround(m) qtMenuShortcutWorkaround(m)
m.exec_(QCursor.pos()) m.exec_(QCursor.pos())

2
qt/aqt/webview.py
View file

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

38
qt/tools/genhooks_gui.py
View file

@ -20,19 +20,19 @@ hooks = [
# Reviewing # Reviewing
################### ###################
Hook( Hook(
name="reviewer_question_did_show", name="reviewer_did_show_question",
args=["card: Card"], args=["card: Card"],
legacy_hook="showQuestion", legacy_hook="showQuestion",
legacy_no_args=True, legacy_no_args=True,
), ),
Hook( Hook(
name="reviewer_answer_did_show", name="reviewer_did_show_answer",
args=["card: Card"], args=["card: Card"],
legacy_hook="showAnswer", legacy_hook="showAnswer",
legacy_no_args=True, legacy_no_args=True,
), ),
Hook( Hook(
name="reviewer_context_menu_will_show", name="reviewer_will_show_context_menu",
args=["reviewer: aqt.reviewer.Reviewer", "menu: QMenu"], args=["reviewer: aqt.reviewer.Reviewer", "menu: QMenu"],
legacy_hook="Reviewer.contextMenuEvent", legacy_hook="Reviewer.contextMenuEvent",
), ),
@ -42,7 +42,7 @@ hooks = [
doc="Called before Anki transitions from the review screen to another screen.", doc="Called before Anki transitions from the review screen to another screen.",
), ),
Hook( Hook(
name="card_text", name="card_will_show",
args=["text: str", "card: Card", "kind: str"], args=["text: str", "card: Card", "kind: str"],
return_type="str", return_type="str",
legacy_hook="prepareQA", legacy_hook="prepareQA",
@ -56,17 +56,17 @@ hooks = [
legacy_hook="browser.setupMenus", legacy_hook="browser.setupMenus",
), ),
Hook( Hook(
name="browser_context_menu_will_show", name="browser_will_show_context_menu",
args=["browser: aqt.browser.Browser", "menu: QMenu"], args=["browser: aqt.browser.Browser", "menu: QMenu"],
legacy_hook="browser.onContextMenu", legacy_hook="browser.onContextMenu",
), ),
Hook( Hook(
name="browser_row_did_change", name="browser_did_change_row",
args=["browser: aqt.browser.Browser"], args=["browser: aqt.browser.Browser"],
legacy_hook="browser.rowChanged", legacy_hook="browser.rowChanged",
), ),
Hook( Hook(
name="webview_context_menu_will_show", name="webview_will_show_context_menu",
args=["webview: aqt.webview.AnkiWebView", "menu: QMenu"], args=["webview: aqt.webview.AnkiWebView", "menu: QMenu"],
legacy_hook="AnkiWebView.contextMenuEvent", legacy_hook="AnkiWebView.contextMenuEvent",
), ),
@ -120,59 +120,59 @@ hooks = [
# Adding cards # Adding cards
################### ###################
Hook( Hook(
name="add_cards_history_menu_will_show", name="add_cards_will_show_history_menu",
args=["addcards: aqt.addcards.AddCards", "menu: QMenu"], args=["addcards: aqt.addcards.AddCards", "menu: QMenu"],
legacy_hook="AddCards.onHistory", legacy_hook="AddCards.onHistory",
), ),
Hook( Hook(
name="add_cards_note_did_add", name="add_cards_did_add_note",
args=["note: anki.notes.Note"], args=["note: anki.notes.Note"],
legacy_hook="AddCards.noteAdded", legacy_hook="AddCards.noteAdded",
), ),
# Editing # Editing
################### ###################
Hook( Hook(
name="editor_buttons_did_init", name="editor_did_init_buttons",
args=["buttons: List", "editor: aqt.editor.Editor"], args=["buttons: List", "editor: aqt.editor.Editor"],
), ),
Hook( Hook(
name="editor_shortcuts_did_init", name="editor_did_init_shortcuts",
args=["shortcuts: List[Tuple]", "editor: aqt.editor.Editor"], args=["shortcuts: List[Tuple]", "editor: aqt.editor.Editor"],
legacy_hook="setupEditorShortcuts", legacy_hook="setupEditorShortcuts",
), ),
Hook( Hook(
name="editor_context_menu_will_show", name="editor_will_show_context_menu",
args=["editor_webview: aqt.editor.EditorWebView", "menu: QMenu"], args=["editor_webview: aqt.editor.EditorWebView", "menu: QMenu"],
legacy_hook="EditorWebView.contextMenuEvent", legacy_hook="EditorWebView.contextMenuEvent",
), ),
Hook( Hook(
name="editor_typing_timer_did_fire", name="editor_did_fire_typing_timer",
args=["note: anki.notes.Note"], args=["note: anki.notes.Note"],
legacy_hook="editTimer", legacy_hook="editTimer",
), ),
Hook( Hook(
name="editor_field_did_gain_focus", name="editor_did_focus_field",
args=["note: anki.notes.Note", "current_field_idx: int"], args=["note: anki.notes.Note", "current_field_idx: int"],
legacy_hook="editFocusGained", legacy_hook="editFocusGained",
), ),
Hook( Hook(
name="editor_field_did_lose_focus", name="editor_did_unfocus_field",
args=["changed: bool", "note: anki.notes.Note", "current_field_idx: int"], args=["changed: bool", "note: anki.notes.Note", "current_field_idx: int"],
return_type="bool", return_type="bool",
legacy_hook="editFocusLost", legacy_hook="editFocusLost",
), ),
Hook( Hook(
name="editor_note_did_load", name="editor_did_load_note",
args=["editor: aqt.editor.Editor"], args=["editor: aqt.editor.Editor"],
legacy_hook="loadNote", legacy_hook="loadNote",
), ),
Hook( Hook(
name="editor_tags_did_update", name="editor_did_update_tags",
args=["note: anki.notes.Note"], args=["note: anki.notes.Note"],
legacy_hook="tagsUpdated", legacy_hook="tagsUpdated",
), ),
Hook( Hook(
name="editor_font_for_field", name="editor_will_use_font_for_field",
args=["font: str"], args=["font: str"],
return_type="str", return_type="str",
legacy_hook="mungeEditingFontName", legacy_hook="mungeEditingFontName",
@ -188,7 +188,7 @@ hooks = [
legacy_no_args=True, legacy_no_args=True,
), ),
Hook( Hook(
name="deck_browser_options_menu_will_show", name="deck_browser_will_show_options_menu",
args=["menu: QMenu", "deck_id: int"], args=["menu: QMenu", "deck_id: int"],
legacy_hook="showDeckOptions", legacy_hook="showDeckOptions",
), ),