71101d041a
Users can now mark individual cards with one of four different coloured flags, instead of relying on a tag that applied to the whole note. - replaced marking functionality in reviewer and browser with new flag options - added flag:x search - marked and leech tags now show in normal tag list in filter screen, instead of being treated specially - the other clients will need updating to set and shown the flags, but flags set in the beta should be preserved by the other clients
667 lines
22 KiB
Python
667 lines
22 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright: Damien Elmes <anki@ichi2.net>
|
|
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
import difflib
|
|
import re
|
|
import cgi
|
|
import unicodedata as ucd
|
|
import html.parser
|
|
|
|
from anki.lang import _, ngettext
|
|
from aqt.qt import *
|
|
from anki.utils import stripHTML, json
|
|
from anki.hooks import addHook, runHook
|
|
from anki.sound import playFromText, clearAudioQueue, play
|
|
from aqt.utils import mungeQA, tooltip, askUserDialog, \
|
|
downArrow
|
|
from aqt.sound import getAudio
|
|
import aqt
|
|
|
|
|
|
class Reviewer:
|
|
"Manage reviews. Maintains a separate state."
|
|
|
|
def __init__(self, mw):
|
|
self.mw = mw
|
|
self.web = mw.web
|
|
self.card = None
|
|
self.cardQueue = []
|
|
self.hadCardQueue = False
|
|
self._answeredIds = []
|
|
self._recordedAudio = None
|
|
self.typeCorrect = None # web init happens before this is set
|
|
self.state = None
|
|
self.bottom = aqt.toolbar.BottomBar(mw, mw.bottomWeb)
|
|
addHook("leech", self.onLeech)
|
|
|
|
def show(self):
|
|
self.mw.col.reset()
|
|
self.web.resetHandlers()
|
|
self.mw.setStateShortcuts(self._shortcutKeys())
|
|
self.web.onBridgeCmd = self._linkHandler
|
|
self.bottom.web.onBridgeCmd = self._linkHandler
|
|
self._reps = None
|
|
self.nextCard()
|
|
|
|
def lastCard(self):
|
|
if self._answeredIds:
|
|
if not self.card or self._answeredIds[-1] != self.card.id:
|
|
try:
|
|
return self.mw.col.getCard(self._answeredIds[-1])
|
|
except TypeError:
|
|
# id was deleted
|
|
return
|
|
|
|
def cleanup(self):
|
|
runHook("reviewCleanup")
|
|
|
|
# Fetching a card
|
|
##########################################################################
|
|
|
|
def nextCard(self):
|
|
elapsed = self.mw.col.timeboxReached()
|
|
if elapsed:
|
|
part1 = ngettext("%d card studied in", "%d cards studied in", elapsed[1]) % elapsed[1]
|
|
mins = int(round(elapsed[0]/60))
|
|
part2 = ngettext("%s minute.", "%s minutes.", mins) % mins
|
|
fin = _("Finish")
|
|
diag = askUserDialog("%s %s" % (part1, part2),
|
|
[_("Continue"), fin])
|
|
diag.setIcon(QMessageBox.Information)
|
|
if diag.run() == fin:
|
|
return self.mw.moveToState("deckBrowser")
|
|
self.mw.col.startTimebox()
|
|
if self.cardQueue:
|
|
# undone/edited cards to show
|
|
c = self.cardQueue.pop()
|
|
c.startTimer()
|
|
self.hadCardQueue = True
|
|
else:
|
|
if self.hadCardQueue:
|
|
# the undone/edited cards may be sitting in the regular queue;
|
|
# need to reset
|
|
self.mw.col.reset()
|
|
self.hadCardQueue = False
|
|
c = self.mw.col.sched.getCard()
|
|
self.card = c
|
|
clearAudioQueue()
|
|
if not c:
|
|
self.mw.moveToState("overview")
|
|
return
|
|
if self._reps is None or self._reps % 100 == 0:
|
|
# we recycle the webview periodically so webkit can free memory
|
|
self._initWeb()
|
|
self._showQuestion()
|
|
|
|
# Audio
|
|
##########################################################################
|
|
|
|
def replayAudio(self, previewer=None):
|
|
if previewer:
|
|
state = previewer._previewState
|
|
c = previewer.card
|
|
else:
|
|
state = self.state
|
|
c = self.card
|
|
clearAudioQueue()
|
|
if state == "question":
|
|
playFromText(c.q())
|
|
elif state == "answer":
|
|
txt = ""
|
|
if self._replayq(c, previewer):
|
|
txt = c.q()
|
|
txt += c.a()
|
|
playFromText(txt)
|
|
|
|
# Initializing the webview
|
|
##########################################################################
|
|
|
|
def revHtml(self):
|
|
extra = self.mw.col.conf.get("reviewExtra", "")
|
|
return f"""
|
|
<div id=_flag>⚑</div>
|
|
<div id=qa></div>
|
|
{extra}
|
|
"""
|
|
|
|
def _initWeb(self):
|
|
self._reps = 0
|
|
# main window
|
|
self.web.stdHtml(self.revHtml(),
|
|
css=["reviewer.css"],
|
|
js=["jquery.js",
|
|
"browsersel.js",
|
|
"mathjax/conf.js",
|
|
"mathjax/MathJax.js",
|
|
"reviewer.js"])
|
|
# show answer / ease buttons
|
|
self.bottom.web.show()
|
|
self.bottom.web.stdHtml(
|
|
self._bottomHTML(),
|
|
css=["toolbar-bottom.css", "reviewer-bottom.css"],
|
|
js=["jquery.js", "reviewer-bottom.js"]
|
|
)
|
|
|
|
# Showing the question
|
|
##########################################################################
|
|
|
|
def _mungeQA(self, buf):
|
|
return self.typeAnsFilter(mungeQA(self.mw.col, buf))
|
|
|
|
def _showQuestion(self):
|
|
self._reps += 1
|
|
self.state = "question"
|
|
self.typedAnswer = None
|
|
c = self.card
|
|
# grab the question and play audio
|
|
if c.isEmpty():
|
|
q = _("""\
|
|
The front of this card is empty. Please run Tools>Empty Cards.""")
|
|
a = ""
|
|
else:
|
|
q = c.q()
|
|
a = c.a()
|
|
if self.autoplay(c):
|
|
playFromText(q)
|
|
# render & update bottom
|
|
q = self._mungeQA(q)
|
|
|
|
bodyclass = "card card%d" % (c.ord+1)
|
|
|
|
self.web.eval("_showQuestion(%s,'%s');" % (json.dumps(q), bodyclass))
|
|
self._drawFlag()
|
|
self._showAnswerButton()
|
|
# if we have a type answer field, focus main web
|
|
if self.typeCorrect:
|
|
self.mw.web.setFocus()
|
|
# user hook
|
|
runHook('showQuestion')
|
|
|
|
def autoplay(self, card):
|
|
return self.mw.col.decks.confForDid(
|
|
card.odid or card.did)['autoplay']
|
|
|
|
def _replayq(self, card, previewer=None):
|
|
s = previewer if previewer else self
|
|
return s.mw.col.decks.confForDid(
|
|
s.card.odid or s.card.did).get('replayq', True)
|
|
|
|
def _drawFlag(self):
|
|
self.web.eval("_drawFlag(%s);" % self.card.userFlag())
|
|
|
|
# Showing the answer
|
|
##########################################################################
|
|
|
|
def _showAnswer(self):
|
|
if self.mw.state != "review":
|
|
# showing resetRequired screen; ignore space
|
|
return
|
|
self.state = "answer"
|
|
c = self.card
|
|
a = c.a()
|
|
# play audio?
|
|
if self.autoplay(c):
|
|
playFromText(a)
|
|
a = self._mungeQA(a)
|
|
# render and update bottom
|
|
self.web.eval("_showAnswer(%s);" % json.dumps(a))
|
|
self._showEaseButtons()
|
|
# user hook
|
|
runHook('showAnswer')
|
|
|
|
# Answering a card
|
|
############################################################
|
|
|
|
def _answerCard(self, ease):
|
|
"Reschedule card and show next."
|
|
if self.mw.state != "review":
|
|
# showing resetRequired screen; ignore key
|
|
return
|
|
if self.state != "answer":
|
|
return
|
|
if self.mw.col.sched.answerButtons(self.card) < ease:
|
|
return
|
|
self.mw.col.sched.answerCard(self.card, ease)
|
|
self._answeredIds.append(self.card.id)
|
|
self.mw.autosave()
|
|
self.nextCard()
|
|
|
|
# Handlers
|
|
############################################################
|
|
|
|
def _shortcutKeys(self):
|
|
return [
|
|
("e", self.mw.onEditCurrent),
|
|
(" ", self.onEnterKey),
|
|
(Qt.Key_Return, self.onEnterKey),
|
|
(Qt.Key_Enter, self.onEnterKey),
|
|
("r", self.replayAudio),
|
|
(Qt.Key_F5, self.replayAudio),
|
|
("Ctrl+1", lambda: self.setFlag(1)),
|
|
("Ctrl+2", lambda: self.setFlag(2)),
|
|
("Ctrl+3", lambda: self.setFlag(3)),
|
|
("Ctrl+4", lambda: self.setFlag(4)),
|
|
("Ctrl+0", lambda: self.setFlag(0)),
|
|
("=", self.onBuryNote),
|
|
("-", self.onBuryCard),
|
|
("!", self.onSuspend),
|
|
("@", self.onSuspendCard),
|
|
("Ctrl+Delete", self.onDelete),
|
|
("v", self.onReplayRecorded),
|
|
("Shift+v", self.onRecordVoice),
|
|
("o", self.onOptions),
|
|
("1", lambda: self._answerCard(1)),
|
|
("2", lambda: self._answerCard(2)),
|
|
("3", lambda: self._answerCard(3)),
|
|
("4", lambda: self._answerCard(4)),
|
|
]
|
|
|
|
def onEnterKey(self):
|
|
if self.state == "question":
|
|
self._getTypedAnswer()
|
|
elif self.state == "answer":
|
|
self._answerCard(self._defaultEase())
|
|
|
|
def _linkHandler(self, url):
|
|
if url == "ans":
|
|
self._getTypedAnswer()
|
|
elif url.startswith("ease"):
|
|
self._answerCard(int(url[4:]))
|
|
elif url == "edit":
|
|
self.mw.onEditCurrent()
|
|
elif url == "more":
|
|
self.showContextMenu()
|
|
else:
|
|
print("unrecognized anki link:", url)
|
|
|
|
# Type in the answer
|
|
##########################################################################
|
|
|
|
typeAnsPat = "\[\[type:(.+?)\]\]"
|
|
|
|
def typeAnsFilter(self, buf):
|
|
if self.state == "question":
|
|
return self.typeAnsQuestionFilter(buf)
|
|
else:
|
|
return self.typeAnsAnswerFilter(buf)
|
|
|
|
def typeAnsQuestionFilter(self, buf):
|
|
self.typeCorrect = None
|
|
clozeIdx = None
|
|
m = re.search(self.typeAnsPat, buf)
|
|
if not m:
|
|
return buf
|
|
fld = m.group(1)
|
|
# if it's a cloze, extract data
|
|
if fld.startswith("cloze:"):
|
|
# get field and cloze position
|
|
clozeIdx = self.card.ord + 1
|
|
fld = fld.split(":")[1]
|
|
# loop through fields for a match
|
|
for f in self.card.model()['flds']:
|
|
if f['name'] == fld:
|
|
self.typeCorrect = self.card.note()[f['name']]
|
|
if clozeIdx:
|
|
# narrow to cloze
|
|
self.typeCorrect = self._contentForCloze(
|
|
self.typeCorrect, clozeIdx)
|
|
self.typeFont = f['font']
|
|
self.typeSize = f['size']
|
|
break
|
|
if not self.typeCorrect:
|
|
if self.typeCorrect is None:
|
|
if clozeIdx:
|
|
warn = _("""\
|
|
Please run Tools>Empty Cards""")
|
|
else:
|
|
warn = _("Type answer: unknown field %s") % fld
|
|
return re.sub(self.typeAnsPat, warn, buf)
|
|
else:
|
|
# empty field, remove type answer pattern
|
|
return re.sub(self.typeAnsPat, "", buf)
|
|
return re.sub(self.typeAnsPat, """
|
|
<center>
|
|
<input type=text id=typeans onkeypress="_typeAnsPress();"
|
|
style="font-family: '%s'; font-size: %spx;">
|
|
</center>
|
|
""" % (self.typeFont, self.typeSize), buf)
|
|
|
|
def typeAnsAnswerFilter(self, buf):
|
|
if not self.typeCorrect:
|
|
return re.sub(self.typeAnsPat, "", buf)
|
|
origSize = len(buf)
|
|
buf = buf.replace("<hr id=answer>", "")
|
|
hadHR = len(buf) != origSize
|
|
# munge correct value
|
|
parser = html.parser.HTMLParser()
|
|
cor = stripHTML(self.mw.col.media.strip(self.typeCorrect))
|
|
# ensure we don't chomp multiple whitespace
|
|
cor = cor.replace(" ", " ")
|
|
cor = parser.unescape(cor)
|
|
cor = cor.replace("\xa0", " ")
|
|
given = self.typedAnswer
|
|
# compare with typed answer
|
|
res = self.correct(given, cor, showBad=False)
|
|
# and update the type answer area
|
|
def repl(match):
|
|
# can't pass a string in directly, and can't use re.escape as it
|
|
# escapes too much
|
|
s = """
|
|
<span style="font-family: '%s'; font-size: %spx">%s</span>""" % (
|
|
self.typeFont, self.typeSize, res)
|
|
if hadHR:
|
|
# a hack to ensure the q/a separator falls before the answer
|
|
# comparison when user is using {{FrontSide}}
|
|
s = "<hr id=answer>" + s
|
|
return s
|
|
return re.sub(self.typeAnsPat, repl, buf)
|
|
|
|
def _contentForCloze(self, txt, idx):
|
|
matches = re.findall("\{\{c%s::(.+?)\}\}"%idx, txt)
|
|
if not matches:
|
|
return None
|
|
def noHint(txt):
|
|
if "::" in txt:
|
|
return txt.split("::")[0]
|
|
return txt
|
|
matches = [noHint(txt) for txt in matches]
|
|
uniqMatches = set(matches)
|
|
if len(uniqMatches) == 1:
|
|
txt = matches[0]
|
|
else:
|
|
txt = ", ".join(matches)
|
|
return txt
|
|
|
|
def tokenizeComparison(self, given, correct):
|
|
# compare in NFC form so accents appear correct
|
|
given = ucd.normalize("NFC", given)
|
|
correct = ucd.normalize("NFC", correct)
|
|
try:
|
|
s = difflib.SequenceMatcher(None, given, correct, autojunk=False)
|
|
except:
|
|
# autojunk was added in python 2.7.1
|
|
s = difflib.SequenceMatcher(None, given, correct)
|
|
givenElems = []
|
|
correctElems = []
|
|
givenPoint = 0
|
|
correctPoint = 0
|
|
offby = 0
|
|
def logBad(old, new, str, array):
|
|
if old != new:
|
|
array.append((False, str[old:new]))
|
|
def logGood(start, cnt, str, array):
|
|
if cnt:
|
|
array.append((True, str[start:start+cnt]))
|
|
for x, y, cnt in s.get_matching_blocks():
|
|
# if anything was missed in correct, pad given
|
|
if cnt and y-offby > x:
|
|
givenElems.append((False, "-"*(y-x-offby)))
|
|
offby = y-x
|
|
# log any proceeding bad elems
|
|
logBad(givenPoint, x, given, givenElems)
|
|
logBad(correctPoint, y, correct, correctElems)
|
|
givenPoint = x+cnt
|
|
correctPoint = y+cnt
|
|
# log the match
|
|
logGood(x, cnt, given, givenElems)
|
|
logGood(y, cnt, correct, correctElems)
|
|
return givenElems, correctElems
|
|
|
|
def correct(self, given, correct, showBad=True):
|
|
"Diff-corrects the typed-in answer."
|
|
givenElems, correctElems = self.tokenizeComparison(given, correct)
|
|
def good(s):
|
|
return "<span class=typeGood>"+cgi.escape(s)+"</span>"
|
|
def bad(s):
|
|
return "<span class=typeBad>"+cgi.escape(s)+"</span>"
|
|
def missed(s):
|
|
return "<span class=typeMissed>"+cgi.escape(s)+"</span>"
|
|
if given == correct:
|
|
res = good(given)
|
|
else:
|
|
res = ""
|
|
for ok, txt in givenElems:
|
|
if ok:
|
|
res += good(txt)
|
|
else:
|
|
res += bad(txt)
|
|
res += "<br>↓<br>"
|
|
for ok, txt in correctElems:
|
|
if ok:
|
|
res += good(txt)
|
|
else:
|
|
res += missed(txt)
|
|
res = "<div><code id=typeans>" + res + "</code></div>"
|
|
return res
|
|
|
|
def _getTypedAnswer(self):
|
|
self.web.evalWithCallback("typeans ? typeans.value : null", self._onTypedAnswer)
|
|
|
|
def _onTypedAnswer(self, val):
|
|
self.typedAnswer = val
|
|
self._showAnswer()
|
|
|
|
# Bottom bar
|
|
##########################################################################
|
|
|
|
def _bottomHTML(self):
|
|
return """
|
|
<center id=outer>
|
|
<table id=innertable width=100%% cellspacing=0 cellpadding=0>
|
|
<tr>
|
|
<td align=left width=50 valign=top class=stat>
|
|
<br>
|
|
<button title="%(editkey)s" onclick="pycmd('edit');">%(edit)s</button></td>
|
|
<td align=center valign=top id=middle>
|
|
</td>
|
|
<td width=50 align=right valign=top class=stat><span id=time class=stattxt>
|
|
</span><br>
|
|
<button onclick="pycmd('more');">%(more)s %(downArrow)s</button>
|
|
</td>
|
|
</tr>
|
|
</table>
|
|
</center>
|
|
<script>
|
|
time = %(time)d;
|
|
</script>
|
|
""" % dict(rem=self._remaining(), edit=_("Edit"),
|
|
editkey=_("Shortcut key: %s") % "E",
|
|
more=_("More"),
|
|
downArrow=downArrow(),
|
|
time=self.card.timeTaken() // 1000)
|
|
|
|
def _showAnswerButton(self):
|
|
if not self.typeCorrect:
|
|
self.bottom.web.setFocus()
|
|
middle = '''
|
|
<span class=stattxt>%s</span><br>
|
|
<button title="%s" id=ansbut onclick='pycmd("ans");'>%s</button>''' % (
|
|
self._remaining(), _("Shortcut key: %s") % _("Space"), _("Show Answer"))
|
|
# wrap it in a table so it has the same top margin as the ease buttons
|
|
middle = "<table cellpadding=0><tr><td class=stat2 align=center>%s</td></tr></table>" % middle
|
|
if self.card.shouldShowTimer():
|
|
maxTime = self.card.timeLimit() / 1000
|
|
else:
|
|
maxTime = 0
|
|
self.bottom.web.eval("showQuestion(%s,%d);" % (
|
|
json.dumps(middle), maxTime))
|
|
self.bottom.web.adjustHeightToFit()
|
|
|
|
def _showEaseButtons(self):
|
|
self.bottom.web.setFocus()
|
|
middle = self._answerButtons()
|
|
self.bottom.web.eval("showAnswer(%s);" % json.dumps(middle))
|
|
|
|
def _remaining(self):
|
|
if not self.mw.col.conf['dueCounts']:
|
|
return ""
|
|
if self.hadCardQueue:
|
|
# if it's come from the undo queue, don't count it separately
|
|
counts = list(self.mw.col.sched.counts())
|
|
else:
|
|
counts = list(self.mw.col.sched.counts(self.card))
|
|
idx = self.mw.col.sched.countIdx(self.card)
|
|
counts[idx] = "<u>%s</u>" % (counts[idx])
|
|
space = " + "
|
|
ctxt = '<font color="#000099">%s</font>' % counts[0]
|
|
ctxt += space + '<font color="#C35617">%s</font>' % counts[1]
|
|
ctxt += space + '<font color="#007700">%s</font>' % counts[2]
|
|
return ctxt
|
|
|
|
def _defaultEase(self):
|
|
if self.mw.col.sched.answerButtons(self.card) == 4:
|
|
return 3
|
|
else:
|
|
return 2
|
|
|
|
def _answerButtonList(self):
|
|
l = ((1, _("Again")),)
|
|
cnt = self.mw.col.sched.answerButtons(self.card)
|
|
if cnt == 2:
|
|
return l + ((2, _("Good")),)
|
|
elif cnt == 3:
|
|
return l + ((2, _("Good")), (3, _("Easy")))
|
|
else:
|
|
return l + ((2, _("Hard")), (3, _("Good")), (4, _("Easy")))
|
|
|
|
def _answerButtons(self):
|
|
times = []
|
|
default = self._defaultEase()
|
|
def but(i, label):
|
|
if i == default:
|
|
extra = "id=defease"
|
|
else:
|
|
extra = ""
|
|
due = self._buttonTime(i)
|
|
return '''
|
|
<td align=center>%s<button %s title="%s" onclick='pycmd("ease%d");'>\
|
|
%s</button></td>''' % (due, extra, _("Shortcut key: %s") % i, i, label)
|
|
buf = "<center><table cellpading=0 cellspacing=0><tr>"
|
|
for ease, label in self._answerButtonList():
|
|
buf += but(ease, label)
|
|
buf += "</tr></table>"
|
|
script = """
|
|
<script>$(function () { $("#defease").focus(); });</script>"""
|
|
return buf + script
|
|
|
|
def _buttonTime(self, i):
|
|
if not self.mw.col.conf['estTimes']:
|
|
return "<div class=spacer></div>"
|
|
txt = self.mw.col.sched.nextIvlStr(self.card, i, True) or " "
|
|
return '<span class=nobold>%s</span><br>' % txt
|
|
|
|
# Leeches
|
|
##########################################################################
|
|
|
|
def onLeech(self, card):
|
|
# for now
|
|
s = _("Card was a leech.")
|
|
if card.queue < 0:
|
|
s += " " + _("It has been suspended.")
|
|
tooltip(s)
|
|
|
|
# Context menu
|
|
##########################################################################
|
|
|
|
# note the shortcuts listed here also need to be defined above
|
|
def showContextMenu(self):
|
|
opts = [
|
|
[_("Flag Card"), [
|
|
[_("Red Flag"), "Ctrl+1", lambda: self.setFlag(1)],
|
|
[_("Purple Flag"), "Ctrl+2", lambda: self.setFlag(2)],
|
|
[_("Green Flag"), "Ctrl+3", lambda: self.setFlag(3)],
|
|
[_("Blue Flag"), "Ctrl+4", lambda: self.setFlag(4)],
|
|
[_("No Flag"), "Ctrl+5", lambda: self.setFlag(0)],
|
|
]],
|
|
[_("Bury Card"), "-", self.onBuryCard],
|
|
[_("Bury Note"), "=", self.onBuryNote],
|
|
[_("Suspend Card"), "@", self.onSuspendCard],
|
|
[_("Suspend Note"), "!", self.onSuspend],
|
|
[_("Delete Note"), "Ctrl+Delete", self.onDelete],
|
|
[_("Options"), "O", self.onOptions],
|
|
None,
|
|
[_("Replay Audio"), "R", self.replayAudio],
|
|
[_("Record Own Voice"), "Shift+V", self.onRecordVoice],
|
|
[_("Replay Own Voice"), "V", self.onReplayRecorded],
|
|
]
|
|
m = QMenu(self.mw)
|
|
self._addMenuItems(m, opts)
|
|
|
|
runHook("Reviewer.contextMenuEvent",self,m)
|
|
m.exec_(QCursor.pos())
|
|
|
|
def _addMenuItems(self, m, rows):
|
|
for row in rows:
|
|
if not row:
|
|
m.addSeparator()
|
|
continue
|
|
if len(row) == 2:
|
|
subm = m.addMenu(row[0])
|
|
self._addMenuItems(subm, row[1])
|
|
continue
|
|
label, scut, func = row
|
|
a = m.addAction(label)
|
|
if scut:
|
|
a.setShortcut(QKeySequence(scut))
|
|
a.triggered.connect(func)
|
|
|
|
|
|
def onOptions(self):
|
|
self.mw.onDeckConf(self.mw.col.decks.get(
|
|
self.card.odid or self.card.did))
|
|
|
|
def setFlag(self, flag):
|
|
self.card.setUserFlag(flag)
|
|
self.card.flush()
|
|
self._drawFlag()
|
|
|
|
def onSuspend(self):
|
|
self.mw.checkpoint(_("Suspend"))
|
|
self.mw.col.sched.suspendCards(
|
|
[c.id for c in self.card.note().cards()])
|
|
tooltip(_("Note suspended."))
|
|
self.mw.reset()
|
|
|
|
def onSuspendCard(self):
|
|
self.mw.checkpoint(_("Suspend"))
|
|
self.mw.col.sched.suspendCards([self.card.id])
|
|
tooltip(_("Card suspended."))
|
|
self.mw.reset()
|
|
|
|
def onDelete(self):
|
|
# need to check state because the shortcut is global to the main
|
|
# window
|
|
if self.mw.state != "review" or not self.card:
|
|
return
|
|
self.mw.checkpoint(_("Delete"))
|
|
cnt = len(self.card.note().cards())
|
|
self.mw.col.remNotes([self.card.note().id])
|
|
self.mw.reset()
|
|
tooltip(ngettext(
|
|
"Note and its %d card deleted.",
|
|
"Note and its %d cards deleted.",
|
|
cnt) % cnt)
|
|
|
|
def onBuryCard(self):
|
|
self.mw.checkpoint(_("Bury"))
|
|
self.mw.col.sched.buryCards([self.card.id])
|
|
self.mw.reset()
|
|
tooltip(_("Card buried."))
|
|
|
|
def onBuryNote(self):
|
|
self.mw.checkpoint(_("Bury"))
|
|
self.mw.col.sched.buryNote(self.card.nid)
|
|
self.mw.reset()
|
|
tooltip(_("Note buried."))
|
|
|
|
def onRecordVoice(self):
|
|
self._recordedAudio = getAudio(self.mw, encode=False)
|
|
self.onReplayRecorded()
|
|
|
|
def onReplayRecorded(self):
|
|
if not self._recordedAudio:
|
|
return tooltip(_("You haven't recorded your voice yet."))
|
|
clearAudioQueue()
|
|
play(self._recordedAudio)
|