mirror of
https://github.com/ankitects/anki.git
synced 2025-11-09 14:17:13 -05:00
284 lines
11 KiB
Python
284 lines
11 KiB
Python
|
|
def _studyScreenState(self, oldState):
|
|
self.currentCard = None
|
|
# if self.deck.finishScheduler:
|
|
# self.deck.finishScheduler()
|
|
self.disableCardMenuItems()
|
|
self.showStudyScreen()
|
|
|
|
# Study screen
|
|
##########################################################################
|
|
|
|
def setupStudyScreen(self):
|
|
return
|
|
self.form.buttonStack.hide()
|
|
self.form.newCardOrder.insertItems(
|
|
0, QStringList(anki.consts.newCardOrderLabels().values()))
|
|
self.form.newCardScheduling.insertItems(
|
|
0, QStringList(anki.consts.newCardSchedulingLabels().values()))
|
|
self.form.revCardOrder.insertItems(
|
|
0, QStringList(anki.consts.revCardOrderLabels().values()))
|
|
self.connect(self.form.optionsHelpButton,
|
|
SIGNAL("clicked()"),
|
|
lambda: QDesktopServices.openUrl(QUrl(
|
|
aqt.appWiki + "StudyOptions")))
|
|
self.connect(self.form.minuteLimit,
|
|
SIGNAL("textChanged(QString)"), self.onMinuteLimitChanged)
|
|
self.connect(self.form.questionLimit,
|
|
SIGNAL("textChanged(QString)"), self.onQuestionLimitChanged)
|
|
self.connect(self.form.newPerDay,
|
|
SIGNAL("textChanged(QString)"), self.onNewLimitChanged)
|
|
self.connect(self.form.startReviewingButton,
|
|
SIGNAL("clicked()"),
|
|
self.onStartReview)
|
|
self.connect(self.form.newCardOrder,
|
|
SIGNAL("activated(int)"), self.onNewCardOrderChanged)
|
|
self.connect(self.form.failedCardMax,
|
|
SIGNAL("editingFinished()"),
|
|
self.onFailedMaxChanged)
|
|
self.connect(self.form.newCategories,
|
|
SIGNAL("clicked()"), self.onNewCategoriesClicked)
|
|
self.connect(self.form.revCategories,
|
|
SIGNAL("clicked()"), self.onRevCategoriesClicked)
|
|
self.form.tabWidget.setCurrentIndex(self.config['studyOptionsTab'])
|
|
|
|
def onNewCategoriesClicked(self):
|
|
aqt.activetags.show(self, "new")
|
|
|
|
def onRevCategoriesClicked(self):
|
|
aqt.activetags.show(self, "rev")
|
|
|
|
def onFailedMaxChanged(self):
|
|
try:
|
|
v = int(self.form.failedCardMax.text())
|
|
if v == 1 or v < 0:
|
|
v = 2
|
|
self.deck.failedCardMax = v
|
|
except ValueError:
|
|
pass
|
|
self.form.failedCardMax.setText(str(self.deck.failedCardMax))
|
|
self.deck.flushMod()
|
|
|
|
def onMinuteLimitChanged(self, qstr):
|
|
try:
|
|
val = float(self.form.minuteLimit.text()) * 60
|
|
if self.deck.sessionTimeLimit == val:
|
|
return
|
|
self.deck.sessionTimeLimit = val
|
|
except ValueError:
|
|
pass
|
|
self.deck.flushMod()
|
|
self.updateStudyStats()
|
|
|
|
def onQuestionLimitChanged(self, qstr):
|
|
try:
|
|
val = int(self.form.questionLimit.text())
|
|
if self.deck.sessionRepLimit == val:
|
|
return
|
|
self.deck.sessionRepLimit = val
|
|
except ValueError:
|
|
pass
|
|
self.deck.flushMod()
|
|
self.updateStudyStats()
|
|
|
|
def onNewLimitChanged(self, qstr):
|
|
try:
|
|
val = int(self.form.newPerDay.text())
|
|
if self.deck.newCardsPerDay == val:
|
|
return
|
|
self.deck.newCardsPerDay = val
|
|
except ValueError:
|
|
pass
|
|
self.deck.flushMod()
|
|
self.deck.reset()
|
|
self.statusView.redraw()
|
|
self.updateStudyStats()
|
|
|
|
def onNewCardOrderChanged(self, ncOrd):
|
|
def uf(obj, field, value):
|
|
if getattr(obj, field) != value:
|
|
setattr(obj, field, value)
|
|
self.deck.flushMod()
|
|
if ncOrd != 0:
|
|
if self.deck.newCardOrder == 0:
|
|
# need to put back in order
|
|
self.mw.startProgress()
|
|
self.mw.updateProgress(_("Ordering..."))
|
|
self.deck.orderNewCards()
|
|
self.deck.finishProgress()
|
|
uf(self.deck, 'newCardOrder', ncOrd)
|
|
elif ncOrd == 0:
|
|
# (re-)randomize
|
|
self.deck.startProgress()
|
|
self.deck.updateProgress(_("Randomizing..."))
|
|
self.deck.randomizeNewCards()
|
|
self.deck.finishProgress()
|
|
uf(self.deck, 'newCardOrder', ncOrd)
|
|
|
|
def updateActives(self):
|
|
labels = [
|
|
_("Show All Due Cards"),
|
|
_("Show Chosen Categories")
|
|
]
|
|
if self.deck.getVar("newActive") or self.deck.getVar("newInactive"):
|
|
new = labels[1]
|
|
else:
|
|
new = labels[0]
|
|
self.form.newCategoryLabel.setText(new)
|
|
if self.deck.getVar("revActive") or self.deck.getVar("revInactive"):
|
|
rev = labels[1]
|
|
else:
|
|
rev = labels[0]
|
|
self.form.revCategoryLabel.setText(rev)
|
|
|
|
def updateStudyStats(self):
|
|
self.form.buttonStack.hide()
|
|
self.deck.reset()
|
|
self.updateActives()
|
|
wasReached = self.deck.timeboxReached()
|
|
sessionColour = '<font color=#0000ff>%s</font>'
|
|
cardColour = '<font color=#0000ff>%s</font>'
|
|
# top label
|
|
h = {}
|
|
h['ret'] = cardColour % (self.deck.revCount+self.deck.failedSoonCount)
|
|
h['new'] = cardColour % self.deck.newCount
|
|
h['newof'] = str(self.deck.newCountAll())
|
|
# counts & time for today
|
|
todayStart = self.deck.failedCutoff - 86400
|
|
sql = "select count(), sum(userTime) from revlog"
|
|
(reps, time_) = self.deck.db.first(
|
|
sql + " where time > :start", start=todayStart)
|
|
h['timeToday'] = sessionColour % (
|
|
anki.utils.fmtTimeSpan(time_ or 0, short=True, point=1))
|
|
h['repsToday'] = sessionColour % reps
|
|
# and yesterday
|
|
yestStart = todayStart - 86400
|
|
(reps, time_) = self.deck.db.first(
|
|
sql + " where time > :start and time <= :end",
|
|
start=yestStart, end=todayStart)
|
|
h['timeTodayChg'] = str(
|
|
anki.utils.fmtTimeSpan(time_ or 0, short=True, point=1))
|
|
h['repsTodayChg'] = str(reps)
|
|
# session counts
|
|
limit = self.deck.sessionTimeLimit
|
|
start = self.deck.sessionStartTime or time.time() - limit
|
|
start2 = self.deck.lastSessionStart or start - limit
|
|
last10 = self.deck.db.scalar(
|
|
"select count(*) from revlog where time >= :t",
|
|
t=start)
|
|
last20 = self.deck.db.scalar(
|
|
"select count(*) from revlog where "
|
|
"time >= :t and time < :t2",
|
|
t=start2, t2=start)
|
|
h['repsInSes'] = sessionColour % last10
|
|
h['repsInSesChg'] = str(last20)
|
|
h['cs_header'] = "<b>" + _("Cards/session:") + "</b>"
|
|
h['cd_header'] = "<b>" + _("Cards/day:") + "</b>"
|
|
h['td_header'] = "<b>" + _("Time/day:") + "</b>"
|
|
h['rd_header'] = "<b>" + _("Reviews due:") + "</b>"
|
|
h['ntod_header'] = "<b>" + _("New today:") + "</b>"
|
|
h['ntot_header'] = "<b>" + _("New total:") + "</b>"
|
|
stats1 = ("""\
|
|
<table>
|
|
<tr><td width=150>%(cs_header)s</td><td width=50><b>%(repsInSesChg)s</b></td>
|
|
<td><b>%(repsInSes)s</b></td></tr></table>
|
|
<hr>
|
|
<table>
|
|
<tr><td width=150>
|
|
%(cd_header)s</td><td width=50><b>%(repsTodayChg)s</b></td>
|
|
<td><b>%(repsToday)s</b></td></tr>
|
|
<tr><td>%(td_header)s</td><td><b>%(timeTodayChg)s</b></td>
|
|
<td><b>%(timeToday)s</b></td></tr>
|
|
</table>""") % h
|
|
|
|
stats2 = ("""\
|
|
<table>
|
|
<tr><td width=180>%(rd_header)s</td><td align=right><b>%(ret)s</b></td></tr>
|
|
<tr><td>%(ntod_header)s</td><td align=right><b>%(new)s</b></td></tr>
|
|
<tr><td>%(ntot_header)s</td><td align=right>%(newof)s</td></tr>
|
|
</table>""") % h
|
|
self.form.optionsLabel.setText("""\
|
|
<p><table><tr>
|
|
%s
|
|
</tr><tr>
|
|
<td><hr>%s<hr></td></tr></table>""" % (stats1, stats2))
|
|
h['tt_header'] = _("Session Statistics")
|
|
h['cs_tip'] = _("The number of cards you studied in the current \
|
|
session (blue) and previous session (black)")
|
|
h['cd_tip'] = _("The number of cards you studied today (blue) and \
|
|
yesterday (black)")
|
|
h['td_tip'] = _("The number of minutes you studied today (blue) and \
|
|
yesterday (black)")
|
|
h['rd_tip'] = _("The number of cards that are waiting to be reviewed \
|
|
today")
|
|
h['ntod_tip'] = _("The number of new cards that are waiting to be \
|
|
learnt today")
|
|
h['ntot_tip'] = _("The total number of new cards in the deck")
|
|
statToolTip = ("""<h1>%(tt_header)s</h1>
|
|
<dl><dt><b>%(cs_header)s</b></dt><dd>%(cs_tip)s</dd></dl>
|
|
<dl><dt><b>%(cd_header)s</b></dt><dd>%(cd_tip)s</dd></dl>
|
|
<dl><dt><b>%(td_header)s</b></dt><dd>%(td_tip)s</dd></dl>
|
|
<dl><dt><b>%(rd_header)s</b></dt><dd>%(rd_tip)s</dd></dl>
|
|
<dl><dt><b>%(ntod_header)s</b></dt><dd>%(ntod_tip)s</dd></dl>
|
|
<dl><dt><b>%(ntot_header)s</b></dt><dd>%(ntot_tip)s<</dd></dl>""") % h
|
|
|
|
self.form.optionsLabel.setToolTip(statToolTip)
|
|
|
|
def showStudyScreen(self):
|
|
# forget last card
|
|
self.lastCard = None
|
|
self.switchToStudyScreen()
|
|
self.updateStudyStats()
|
|
self.form.startReviewingButton.setFocus()
|
|
self.setupStudyOptions()
|
|
self.form.studyOptionsFrame.setMaximumWidth(500)
|
|
self.form.studyOptionsFrame.show()
|
|
|
|
def setupStudyOptions(self):
|
|
self.form.newPerDay.setText(str(self.deck.newCardsPerDay))
|
|
lim = self.deck.sessionTimeLimit/60
|
|
if int(lim) == lim:
|
|
lim = int(lim)
|
|
self.form.minuteLimit.setText(str(lim))
|
|
self.form.questionLimit.setText(str(self.deck.sessionRepLimit))
|
|
self.form.newCardOrder.setCurrentIndex(self.deck.newCardOrder)
|
|
self.form.newCardScheduling.setCurrentIndex(self.deck.newCardSpacing)
|
|
self.form.revCardOrder.setCurrentIndex(self.deck.revCardOrder)
|
|
self.form.failedCardsOption.clear()
|
|
if self.deck.getFailedCardPolicy() == 5:
|
|
labels = failedCardOptionLabels().values()
|
|
else:
|
|
labels = failedCardOptionLabels().values()[0:-1]
|
|
self.form.failedCardsOption.insertItems(0, labels)
|
|
self.form.failedCardsOption.setCurrentIndex(self.deck.getFailedCardPolicy())
|
|
self.form.failedCardMax.setText(unicode(self.deck.failedCardMax))
|
|
|
|
def onStartReview(self):
|
|
def uf(obj, field, value):
|
|
if getattr(obj, field) != value:
|
|
setattr(obj, field, value)
|
|
self.deck.flushMod()
|
|
self.form.studyOptionsFrame.hide()
|
|
# make sure the size is updated before button stack shown
|
|
self.app.processEvents()
|
|
uf(self.deck, 'newCardSpacing',
|
|
self.form.newCardScheduling.currentIndex())
|
|
uf(self.deck, 'revCardOrder',
|
|
self.form.revCardOrder.currentIndex())
|
|
pol = self.deck.getFailedCardPolicy()
|
|
if (pol != 5 and pol !=
|
|
self.form.failedCardsOption.currentIndex()):
|
|
self.deck.setFailedCardPolicy(
|
|
self.form.failedCardsOption.currentIndex())
|
|
self.deck.flushMod()
|
|
self.deck.reset()
|
|
if not self.deck.finishScheduler:
|
|
self.deck.startTimebox()
|
|
self.config['studyOptionsTab'] = self.form.tabWidget.currentIndex()
|
|
self.moveToState("getQuestion")
|
|
|
|
def onStudyOptions(self):
|
|
if self.state == "studyScreen":
|
|
pass
|
|
else:
|
|
self.moveToState("studyScreen")
|