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
Anki/aqt/reviewer.py

540 lines
17 KiB
Python
Raw Blame History

# -*- coding: utf-8 -*-
# Copyright: Damien Elmes <anki@ichi2.net>
# License: GNU GPL, version 3 or later; http://www.gnu.org/copyleft/gpl.html
import time, os, stat, shutil, difflib, simplejson
import unicodedata as ucd
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from anki.utils import fmtTimeSpan, stripHTML
from anki.hooks import addHook, runHook, runFilter
from anki.sound import playFromText, clearAudioQueue
from aqt.utils import mungeQA, getBase
import aqt
class Reviewer(object):
"Manage reviews. Maintains a separate state."
def __init__(self, mw):
self.mw = mw
self.web = mw.web
self.card = None
self.cardQueue = []
self._answeredIds = []
self.state = None
self._setupStatus()
def show(self):
self.web.setKeyHandler(self._keyHandler)
self.web.setLinkHandler(self._linkHandler)
self._initWeb()
def lastCard(self):
if self._answeredIds:
if not self.card or self._answeredIds[-1] != self.card.id:
return self.mw.deck.getCard(self._answeredIds[-1])
# Fetching a card
##########################################################################
def _getCard(self):
if self.cardQueue:
# a card has been retrieved from undo
c = self.cardQueue.pop()
else:
c = self.mw.deck.sched.getCard()
self.card = c
clearAudioQueue()
if c:
self.mw.enableCardMenuItems()
self._showStatus()
self._maybeEnableSound()
#self.updateMarkAction()
self.state = "question"
self._showQuestion()
else:
self._hideStatus()
self.mw.disableCardMenuItems()
if self.mw.deck.cardCount():
self._showCongrats()
else:
self._showEmpty()
def _maybeEnableSound(self):
print "enable sound fixme"
return
snd = (hasSound(self.reviewer.card.q()) or
(hasSound(self.reviewer.card.a()) and
self.state != "getQuestion"))
self.form.actionRepeatAudio.setEnabled(snd)
# Initializing the webview
##########################################################################
_revHtml = """
<table width=100%% height=100%%><tr valign=middle><td>
<div id=q></div>
<hr class=inv>
<div id=a></div>
<div id=filler></div>
</td></tr></table>
<a id=ansbut class="but ansbut" href=ans onclick="showans();">
<div class=ansbut>%(showans)s</div>
</a>
<div id=easebuts>
</div>
<script>
function updateQA (qa) {
$("#q").html(qa[0]);
$("#a").html(qa[1]);
$("#easebuts").html(qa[2]).addClass("inv");
$("#ansbut").show();
$("body").removeClass().addClass(qa[3]);
};
function showans () {
$(".inv").removeClass('inv');
$("#ansbut").hide();
location.hash = "a";
};
$(document).ready(function () {
$(".ansbut").focus();
});
</script>
"""
def _initWeb(self):
self.web.stdHtml(self._revHtml % dict(
showans=_("Show Answer")), self._styles(),
loadCB=lambda x: self._getCard())
# Showing the question (and preparing answer)
##########################################################################
def _showQuestion(self):
self.state = "question"
# fixme: timeboxing
# fixme: q/a separation
# fixme: prevent audio from repeating
# fixme: include placeholder for type answer result
c = self.card
# original question with sounds
q = c.q()
a = c.a("a inv")
if (#self.state != self.oldState and not nosound
self.mw.config['autoplaySounds']):
playFromText(q)
# render
# buf = self.typeAnsResult()
esc = self.mw.deck.media.escapeImages
q=esc(mungeQA(q))
a=esc(mungeQA(a))
self.web.eval("updateQA(%s);" % simplejson.dumps(
[q, a, self._answerButtons(), c.cssClass()]))
runHook('showQuestion')
# Showing the answer
##########################################################################
def _showAnswer(self):
self.state = "answer"
c = self.card
a = c.a()
if self.mw.config['autoplaySounds']:
playFromText(a)
# render
runHook('showAnswer')
# Review buttons
##########################################################################
def _reviewButtons(self):
# type answer area
buf = self.typeAnsInput()
# show answer button
buf += """
<a id=ansbut class="but ansbut" href=ans onclick="showans();">
<div class=ansbut>%s</div>
</a>
""" % _("Show Answer")
# ease buttons
buf += self._answerButtons()
return buf
def _defaultEase(self):
if self.mw.deck.sched.answerButtons(self.card) == 4:
return 3
else:
return 2
def _answerButtons(self):
if self.mw.deck.sched.answerButtons(self.card) == 4:
labels = (_("Again"), _("Hard"), _("Good"), _("Easy"))
else:
labels = (_("Again"), _("Good"), _("Easy"))
times = []
buttons = []
default = self._defaultEase()
def but(label, i):
if i == default:
extra=" id=defease"
else:
extra = ""
return '''
<a %s class="but easebut" href=ease%d>%s</a>''' % (extra, i, label)
for i in range(0, len(labels)):
times.append(self._buttonTime(i, default-1))
buttons.append(but(labels[i], i+1))
buf = ("<table><tr><td align=center>" +
"</td><td align=center>".join(times) + "</td></tr>")
buf += ("<tr><td>" +
"</td><td>".join(buttons) + "</td></tr></table>")
return "<center>" + buf + "</center>"
return buf
def _buttonTime(self, i, green):
if self.mw.config['suppressEstimates']:
return ""
txt = self.mw.deck.sched.nextIvlStr(self.card, i+1, True)
if i == 0:
txt = '<span style="color: #700">%s</span>' % txt
elif i == green:
txt = '<span style="color: #070">%s</span>' % txt
txt = '<span class=time>%s</span>' % txt
return txt
# Answering a card
############################################################
def _answerCard(self, ease):
"Reschedule card and show next."
self.mw.deck.sched.answerCard(self.card, ease)
self._answeredIds.append(self.card.id)
print "fixme: save"
self._getCard()
# Handlers
############################################################
def _keyHandler(self, evt):
if self.state == "question":
show = False
if evt.key() in (Qt.Key_Enter,
Qt.Key_Return):
show = True
elif evt.key() == Qt.Key_Space and not self.typeAns():
show = True
if show:
self._showAnswer()
self.web.eval("showans();")
return True
elif self.state == "answer":
if evt.key() in (Qt.Key_Enter,
Qt.Key_Return,
Qt.Key_Space):
self._answerCard(self._defaultEase())
return True
else:
key = unicode(evt.text())
if key and key >= "1" and key <= "4":
key=int(key)
if self.card.queue == 2 or key < 4:
self._answerCard(key)
return True
def _linkHandler(self, url):
if url == "ans":
self._showAnswer()
elif url.startswith("ease"):
self._answerCard(int(url[4:]))
# CSS
##########################################################################
_css = """
a.ansbut {
bottom: 1em;
height: 40px;
left: 50%;
margin-left: -125px;
position: fixed;
width: 250px;
font-size: 100%;
}
a.ansbut:focus {
background: #c7c7c7;
}
div.ansbut {
position: relative; top: 25%;
}
div#q, div#a {
margin: 0px;
}
#easebuts {
bottom: 1em;
height: 55px;
left: 50%;
margin-left: -200px;
position: fixed;
width: 400px;
font-size: 100%;
}
.easebut {
width: 60px;
font-size: 100%;
}
.time {
background: #eee;
padding: 5px;
border-radius: 10px;
}
div#filler {
height: 30px;
}
.q { margin-bottom: 1em; }
.a { margin-top: 1em; }
.inv { visibility: hidden; }
"""
def _styles(self):
css = self.mw.sharedCSS
css += self.mw.deck.allCSS()
css += self._css
css = runFilter("addStyles", css)
return css
# Type in the answer
##########################################################################
failedCharColour = "#FF0000"
passedCharColour = "#00FF00"
futureWarningColour = "#FF0000"
# if self.card.cardModel.typeAnswer:
# try:
# cor = stripMedia(stripHTML(self.card.fact[
# self.card.cardModel.typeAnswer]))
# except KeyError:
# self.card.cardModel.typeAnswer = ""
# cor = ""
# if cor:
# given = unicode(self.main.typeAnswerField.text())
# res = self.correct(cor, given)
# a = res + "<br>" + a
# fixme: type answer undo area shouldn't trigger global shortcut
# class QLineEditNoUndo(QLineEdit):
# def __init__(self, parent):
# self.parent = parent
# QLineEdit.__init__(self, parent)
# def keyPressEvent(self, evt):
# if evt.matches(QKeySequence.Undo):
# evt.accept()
# if self.parent.form.actionUndo.isEnabled():
# self.parent.onUndo()
# else:
# return QLineEdit.keyPressEvent(self, evt)
def typeAns(self):
"True if current card has answer typing enabled."
return self.card.template()['typeAns']
def typeAnsInput(self):
return ""
if self.card.cardModel.typeAnswer:
self.adjustInputFont()
def getFont(self):
sz = 20
fn = u"Arial"
for fm in self.card.fact.model.fieldModels:
if fm.name == self.card.cardModel.typeAnswer:
sz = fm.quizFontSize or sz
fn = fm.quizFontFamily or fn
break
return (fn, sz)
def adjustInputFont(self):
(fn, sz) = self.getFont()
f = QFont()
f.setFamily(fn)
f.setPixelSize(sz)
self.main.typeAnswerField.setFont(f)
# add some extra space as layout is wrong on osx
self.main.typeAnswerField.setFixedHeight(
self.main.typeAnswerField.sizeHint().height() + 10)
def calculateOkBadStyle(self):
"Precalculates styles for correct and incorrect part of answer"
(fn, sz) = self.getFont()
st = "background: %s; color: #000; font-size: %dpx; font-family: %s;"
self.styleOk = st % (passedCharColour, sz, fn)
self.styleBad = st % (failedCharColour, sz, fn)
def ok(self, a):
"returns given sring in style correct (green)"
if len(a) == 0:
return ""
return "<span style='%s'>%s</span>" % (self.styleOk, a)
def bad(self, a):
"returns given sring in style incorrect (red)"
if len(a) == 0:
return ""
return "<span style='%s'>%s</span>" % (self.styleBad, a)
def head(self, a):
return a[:len(a) - 1]
def tail(self, a):
return a[len(a) - 1:]
def applyStyle(self, testChar, correct, wrong):
"Calculates answer fragment depending on testChar's unicode category"
ZERO_SIZE = 'Mn'
if ucd.category(testChar) == ZERO_SIZE:
return self.ok(self.head(correct)) + self.bad(self.tail(correct) + wrong)
return self.ok(correct) + self.bad(wrong)
def correct(self, a, b):
"Diff-corrects the typed-in answer."
if b == "":
return "";
self.calculateOkBadStyle()
ret = ""
lastEqual = ""
s = difflib.SequenceMatcher(None, b, a)
for tag, i1, i2, j1, j2 in s.get_opcodes():
if tag == "equal":
lastEqual = b[i1:i2]
elif tag == "replace":
ret += self.applyStyle(b[i1], lastEqual,
b[i1:i2] + ("-" * ((j2 - j1) - (i2 - i1))))
lastEqual = ""
elif tag == "delete":
ret += self.applyStyle(b[i1], lastEqual, b[i1:i2])
lastEqual = ""
elif tag == "insert":
dashNum = (j2 - j1) if ucd.category(a[j1]) != 'Mn' else ((j2 - j1) - 1)
ret += self.applyStyle(a[j1], lastEqual, "-" * dashNum)
lastEqual = ""
return ret + self.ok(lastEqual)
# Deck finished case
##########################################################################
def _showCongrats(self):
self.state = "congrats"
self.card = None
self.deck.db.flush()
self.hideButtons()
self.disableCardMenuItems()
self.switchToCongratsScreen()
self.form.learnMoreButton.setEnabled(
not not self.deck.newAvail)
self.startRefreshTimer()
self.bodyView.setState(state)
# focus finish button
self.form.finishButton.setFocus()
runHook('deckFinished')
def drawDeckFinishedMessage(self):
"Tell the user the deck is finished."
self.main.mainWin.congratsLabel.setText(
self.main.deck.deckFinishedMsg())
# Deck empty case
##########################################################################
def _showEmpty(self):
self.state = "empty"
self.switchToWelcomeScreen()
self.disableCardMenuItems()
# Status bar
##########################################################################
def _setupStatus(self):
self._statusWidgets = []
sb = self.mw.form.statusbar
def addWgt(w, stretch=0):
w.setShown(False)
sb.addWidget(w, stretch)
self._statusWidgets.append(w)
def vertSep():
spacer = QFrame()
spacer.setFrameStyle(QFrame.VLine)
spacer.setFrameShadow(QFrame.Plain)
spacer.setStyleSheet("* { color: #888; }")
return spacer
# left spacer
space = QWidget()
addWgt(space, 1)
# remaining
self.remText = QLabel()
addWgt(self.remText, 0)
# progress
addWgt(vertSep())
class QClickableProgress(QProgressBar):
url = "http://ichi2.net/anki/wiki/ProgressBars"
def mouseReleaseEvent(self, evt):
QDesktopServices.openUrl(QUrl(self.url))
progressBarSize = (50, 14)
self.progressBar = QClickableProgress()
self.progressBar.setFixedSize(*progressBarSize)
self.progressBar.setMaximum(100)
self.progressBar.setTextVisible(False)
if QApplication.instance().style().objectName() != "plastique":
self.plastiqueStyle = QStyleFactory.create("plastique")
self.progressBar.setStyle(self.plastiqueStyle)
addWgt(self.progressBar, 0)
def _showStatus(self):
self._showStatusWidgets(True)
self._updateRemaining()
self._updateProgress()
def _hideStatus(self):
self._showStatusWidgets(False)
def _showStatusWidgets(self, shown=True):
for w in self._statusWidgets:
w.setShown(shown)
self.mw.form.statusbar.hideOrShow()
# fixme: only show progress for reviews, and only when revs due?
def _updateRemaining(self):
counts = list(self.mw.deck.sched.counts())
idx = self.mw.deck.sched.countIdx(self.card)
counts[idx] = "<u>%s</u>" % (counts[idx]+1)
space = "&nbsp;" * 2
ctxt = '<font color="#000099">%s</font>' % counts[0]
ctxt += space + '<font color="#990000">%s</font>' % counts[1]
ctxt += space + '<font color="#007700">%s</font>' % counts[2]
buf = _("Remaining: %s") % ctxt
self.remText.setText(buf)
def _updateProgress(self):
p = QPalette()
p.setColor(QPalette.Base, QColor("black"))
p.setColor(QPalette.Button, QColor("black"))
perc = 50
if perc == 0:
p.setColor(QPalette.Highlight, QColor("black"))
elif perc < 50:
p.setColor(QPalette.Highlight, QColor("#ee0000"))
elif perc < 65:
p.setColor(QPalette.Highlight, QColor("#ee7700"))
elif perc < 75:
p.setColor(QPalette.Highlight, QColor("#eeee00"))
else:
p.setColor(QPalette.Highlight, QColor("#00ee00"))
self.progressBar.setPalette(p)
self.progressBar.setValue(perc)
Reference in a new issue View git blame Copy permalink