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

facts->notes

Browse source
This commit is contained in:
Damien Elmes 2011-11-23 13:35:14 +09:00
parent be921563f0
commit 87da9f48b1
11 changed files with 194 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

73
aqt/addcards.py
View file

@ -6,7 +6,6 @@ from aqt.qt import *
import sys, re import sys, re
import aqt.forms import aqt.forms
import anki import anki
from anki.facts import Fact
from anki.errors import * from anki.errors import *
from anki.utils import stripHTML from anki.utils import stripHTML
from aqt.utils import saveGeom, restoreGeom, showWarning, askUser, shortcut, \ from aqt.utils import saveGeom, restoreGeom, showWarning, askUser, shortcut, \
@ -37,7 +36,7 @@ class AddCards(QDialog):
addHook('currentModelChanged', self.onReset) addHook('currentModelChanged', self.onReset)
self.mw.requireReset(modal=True) self.mw.requireReset(modal=True)
self.open() self.open()
self.setupNewFact() self.setupNewNote()
def setupEditor(self): def setupEditor(self):
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, True) self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, True)
@ -75,78 +74,78 @@ class AddCards(QDialog):
b.setEnabled(False) b.setEnabled(False)
self.historyButton = b self.historyButton = b
# FIXME: need to make sure to clean up fact on exit # FIXME: need to make sure to clean up note on exit
def setupNewFact(self, set=True): def setupNewNote(self, set=True):
f = self.mw.deck.newFact() f = self.mw.deck.newNote()
f.tags = f.model()['tags'] f.tags = f.model()['tags']
if set: if set:
self.editor.setFact(f) self.editor.setNote(f)
return f return f
def onReset(self, model=None, keep=False): def onReset(self, model=None, keep=False):
oldFact = self.editor.fact oldNote = self.editor.note
fact = self.setupNewFact(set=False) note = self.setupNewNote(set=False)
flds = fact.model()['flds'] flds = note.model()['flds']
# copy fields from old fact # copy fields from old note
if oldFact: if oldNote:
if not keep: if not keep:
self.removeTempFact(oldFact) self.removeTempNote(oldNote)
for n in range(len(fact.fields)): for n in range(len(note.fields)):
try: try:
if not keep or flds[n]['sticky']: if not keep or flds[n]['sticky']:
fact.fields[n] = oldFact.fields[n] note.fields[n] = oldNote.fields[n]
else: else:
fact.fields[n] = "" note.fields[n] = ""
except IndexError: except IndexError:
break break
self.editor.setFact(fact) self.editor.setNote(note)
def removeTempFact(self, fact): def removeTempNote(self, note):
if not fact or not fact.id: if not note or not note.id:
return return
# we don't have to worry about cards; just the fact # we don't have to worry about cards; just the note
self.mw.deck._remFacts([fact.id]) self.mw.deck._remNotes([note.id])
def addHistory(self, fact): def addHistory(self, note):
txt = stripHTMLMedia(",".join(fact.fields))[:30] txt = stripHTMLMedia(",".join(note.fields))[:30]
self.history.append((fact.id, txt)) self.history.append((note.id, txt))
self.history = self.history[-15:] self.history = self.history[-15:]
self.historyButton.setEnabled(True) self.historyButton.setEnabled(True)
def onHistory(self): def onHistory(self):
m = QMenu(self) m = QMenu(self)
for fid, txt in self.history: for nid, txt in self.history:
a = m.addAction(_("Edit %s" % txt)) a = m.addAction(_("Edit %s" % txt))
a.connect(a, SIGNAL("triggered()"), a.connect(a, SIGNAL("triggered()"),
lambda fid=fid: self.editHistory(fid)) lambda nid=nid: self.editHistory(nid))
m.exec_(self.historyButton.mapToGlobal(QPoint(0,0))) m.exec_(self.historyButton.mapToGlobal(QPoint(0,0)))
def editHistory(self, fid): def editHistory(self, nid):
browser = aqt.dialogs.open("Browser", self.mw) browser = aqt.dialogs.open("Browser", self.mw)
browser.form.searchEdit.setText("fid:%d" % fid) browser.form.searchEdit.setText("nid:%d" % nid)
browser.onSearch() browser.onSearch()
def addFact(self, fact): def addNote(self, note):
if any(fact.problems()): if any(note.problems()):
showWarning(_( showWarning(_(
"Some fields are missing or not unique."), "Some fields are missing or not unique."),
help="AddItems#AddError") help="AddItems#AddError")
return return
cards = self.mw.deck.addFact(fact) cards = self.mw.deck.addNote(note)
if not cards: if not cards:
showWarning(_("""\ showWarning(_("""\
The input you have provided would make an empty The input you have provided would make an empty
question or answer on all cards."""), help="AddItems") question or answer on all cards."""), help="AddItems")
return return
self.addHistory(fact) self.addHistory(note)
# FIXME: return to overview on add? # FIXME: return to overview on add?
return fact return note
def addCards(self): def addCards(self):
self.editor.saveNow() self.editor.saveNow()
fact = self.editor.fact note = self.editor.note
fact = self.addFact(fact) note = self.addNote(note)
if not fact: if not note:
return return
tooltip("Added", period=500) tooltip("Added", period=500)
# stop anything playing # stop anything playing
@ -168,8 +167,8 @@ question or answer on all cards."""), help="AddItems")
removeHook('reset', self.onReset) removeHook('reset', self.onReset)
removeHook('currentModelChanged', self.onReset) removeHook('currentModelChanged', self.onReset)
clearAudioQueue() clearAudioQueue()
self.removeTempFact(self.editor.fact) self.removeTempNote(self.editor.note)
self.editor.setFact(None) self.editor.setNote(None)
self.modelChooser.cleanup() self.modelChooser.cleanup()
self.mw.maybeReset() self.mw.maybeReset()
saveGeom(self, "add") saveGeom(self, "add")

144
aqt/browser.py
View file

@ -36,7 +36,7 @@ class DeckModel(QAbstractTableModel):
self.deck = browser.deck self.deck = browser.deck
self.sortKey = None self.sortKey = None
self.activeCols = self.deck.conf.get( self.activeCols = self.deck.conf.get(
"activeCols", ["factFld", "template", "cardDue", "cardEase"]) "activeCols", ["noteFld", "template", "cardDue", "cardEase"])
self.cards = [] self.cards = []
self.cardObjs = {} self.cardObjs = {}
@ -46,9 +46,9 @@ class DeckModel(QAbstractTableModel):
self.cardObjs[id] = self.deck.getCard(id) self.cardObjs[id] = self.deck.getCard(id)
return self.cardObjs[id] return self.cardObjs[id]
def refreshFact(self, fact): def refreshNote(self, note):
refresh = False refresh = False
for c in fact.cards(): for c in note.cards():
if c.id in self.cardObjs: if c.id in self.cardObjs:
del self.cardObjs[c.id] del self.cardObjs[c.id]
refresh = True refresh = True
@ -123,7 +123,7 @@ class DeckModel(QAbstractTableModel):
def beginReset(self): def beginReset(self):
self.browser.editor.saveNow() self.browser.editor.saveNow()
self.browser.editor.setFact(None, hide=False) self.browser.editor.setNote(None, hide=False)
self.browser.mw.progress.start() self.browser.mw.progress.start()
self.saveSelection() self.saveSelection()
self.beginResetModel() self.beginResetModel()
@ -192,7 +192,7 @@ class DeckModel(QAbstractTableModel):
except: except:
# debugging # debugging
print column, self.activeCols print column, self.activeCols
return "factFld" return "noteFld"
return type return type
def columnData(self, index): def columnData(self, index):
@ -204,17 +204,17 @@ class DeckModel(QAbstractTableModel):
return self.question() return self.question()
elif type == "answer": elif type == "answer":
return self.answer() return self.answer()
elif type == "factFld": elif type == "noteFld":
f = c.fact() f = c.note()
return self.formatQA(f.fields[self.deck.models.sortIdx(f.model())]) return self.formatQA(f.fields[self.deck.models.sortIdx(f.model())])
elif type == "template": elif type == "template":
return c.template()['name'] return c.template()['name']
elif type == "cardDue": elif type == "cardDue":
return self.nextDue(c, index) return self.nextDue(c, index)
elif type == "factCrt": elif type == "noteCrt":
return time.strftime("%Y-%m-%d", time.localtime(c.fact().id/1000)) return time.strftime("%Y-%m-%d", time.localtime(c.note().id/1000))
elif type == "factMod": elif type == "noteMod":
return time.strftime("%Y-%m-%d", time.localtime(c.fact().mod)) return time.strftime("%Y-%m-%d", time.localtime(c.note().mod))
elif type == "cardMod": elif type == "cardMod":
return time.strftime("%Y-%m-%d", time.localtime(c.mod)) return time.strftime("%Y-%m-%d", time.localtime(c.mod))
elif type == "cardReps": elif type == "cardReps":
@ -231,8 +231,8 @@ class DeckModel(QAbstractTableModel):
return "%d%%" % (c.factor/10) return "%d%%" % (c.factor/10)
elif type == "cardGroup": elif type == "cardGroup":
return self.browser.mw.deck.groups.name(c.gid) return self.browser.mw.deck.groups.name(c.gid)
elif type == "factGroup": elif type == "noteGroup":
return self.browser.mw.deck.groups.name(c.fact().gid) return self.browser.mw.deck.groups.name(c.note().gid)
def question(self): def question(self):
return self.formatQA(c.a()) return self.formatQA(c.a())
@ -280,7 +280,7 @@ class StatusDelegate(QItemDelegate):
painter.save() painter.save()
painter.fillRect(option.rect, brush) painter.fillRect(option.rect, brush)
painter.restore() painter.restore()
elif c.fact().hasTag("Marked"): elif c.note().hasTag("Marked"):
if index.row() % 2 == 0: if index.row() % 2 == 0:
brush = QBrush(QColor(COLOUR_MARKED1)) brush = QBrush(QColor(COLOUR_MARKED1))
else: else:
@ -355,14 +355,14 @@ class Browser(QMainWindow):
c(f.actionOptions, s, self.onOptions) c(f.actionOptions, s, self.onOptions)
c(f.actionUndo, s, self.mw.onUndo) c(f.actionUndo, s, self.mw.onUndo)
c(f.actionInvertSelection, s, self.invertSelection) c(f.actionInvertSelection, s, self.invertSelection)
c(f.actionSelectFacts, s, self.selectFacts) c(f.actionSelectNotes, s, self.selectNotes)
c(f.actionFindReplace, s, self.onFindReplace) c(f.actionFindReplace, s, self.onFindReplace)
c(f.actionFindDuplicates, s, self.onFindDupes) c(f.actionFindDuplicates, s, self.onFindDupes)
# jumps # jumps
c(f.actionPreviousCard, s, self.onPreviousCard) c(f.actionPreviousCard, s, self.onPreviousCard)
c(f.actionNextCard, s, self.onNextCard) c(f.actionNextCard, s, self.onNextCard)
c(f.actionFind, s, self.onFind) c(f.actionFind, s, self.onFind)
c(f.actionFact, s, self.onFact) c(f.actionNote, s, self.onNote)
c(f.actionTags, s, self.onTags) c(f.actionTags, s, self.onTags)
c(f.actionSort, s, self.onSort) c(f.actionSort, s, self.onSort)
c(f.actionCardList, s, self.onCardList) c(f.actionCardList, s, self.onCardList)
@ -381,7 +381,7 @@ class Browser(QMainWindow):
saveSplitter(self.form.splitter_2, "editor2") saveSplitter(self.form.splitter_2, "editor2")
saveSplitter(self.form.splitter_3, "editor3") saveSplitter(self.form.splitter_3, "editor3")
self.editor.saveNow() self.editor.saveNow()
self.editor.setFact(None) self.editor.setNote(None)
saveGeom(self, "editor") saveGeom(self, "editor")
saveState(self, "editor") saveState(self, "editor")
saveHeader(self.form.tableView.horizontalHeader(), "editor") saveHeader(self.form.tableView.horizontalHeader(), "editor")
@ -407,10 +407,10 @@ class Browser(QMainWindow):
('answer', _("Answer")), ('answer', _("Answer")),
('template', _("Card")), ('template', _("Card")),
('cardGroup', _("C.Group")), ('cardGroup', _("C.Group")),
('factGroup', _("I.Group")), ('noteGroup', _("I.Group")),
('factFld', _("Sort Field")), ('noteFld', _("Sort Field")),
('factCrt', _("Created")), ('noteCrt', _("Created")),
('factMod', _("Edited")), ('noteMod', _("Edited")),
('cardMod', _("Reviewed")), ('cardMod', _("Reviewed")),
('cardDue', _("Due")), ('cardDue', _("Due")),
('cardIvl', _("Interval")), ('cardIvl', _("Interval")),
@ -439,7 +439,7 @@ class Browser(QMainWindow):
self.form.searchEdit.setCompleter(self.searchComp) self.form.searchEdit.setCompleter(self.searchComp)
def onSearch(self, reset=True): def onSearch(self, reset=True):
"Careful: if reset is true, the current fact is saved." "Careful: if reset is true, the current note is saved."
txt = unicode(self.form.searchEdit.text()).strip() txt = unicode(self.form.searchEdit.text()).strip()
sh = self.mw.config['searchHistory'] sh = self.mw.config['searchHistory']
if txt not in sh: if txt not in sh:
@ -471,7 +471,7 @@ class Browser(QMainWindow):
return selected return selected
def onReset(self): def onReset(self):
self.editor.setFact(None) self.editor.setNote(None)
self.onSearch() self.onSearch()
# Table view & editor # Table view & editor
@ -494,21 +494,21 @@ class Browser(QMainWindow):
self.editor.stealFocus = False self.editor.stealFocus = False
def onRowChanged(self, current, previous): def onRowChanged(self, current, previous):
"Update current fact and hide/show editor." "Update current note and hide/show editor."
show = self.model.cards and self.updateTitle() == 1 show = self.model.cards and self.updateTitle() == 1
self.form.splitter_2.widget(1).setShown(not not show) self.form.splitter_2.widget(1).setShown(not not show)
if not show: if not show:
self.editor.setFact(None) self.editor.setNote(None)
else: else:
self.card = self.model.getCard( self.card = self.model.getCard(
self.form.tableView.selectionModel().currentIndex()) self.form.tableView.selectionModel().currentIndex())
self.editor.setFact(self.card.fact()) self.editor.setNote(self.card.note())
self.editor.card = self.card self.editor.card = self.card
self.showCardInfo(self.card) self.showCardInfo(self.card)
self.updateToggles() self.updateToggles()
def refreshCurrentCard(self, fact): def refreshCurrentCard(self, note):
self.model.refreshFact(fact) self.model.refreshNote(note)
# Headers & sorting # Headers & sorting
###################################################################### ######################################################################
@ -533,7 +533,7 @@ class Browser(QMainWindow):
def onSortChanged(self, idx, ord): def onSortChanged(self, idx, ord):
type = self.model.activeCols[idx] type = self.model.activeCols[idx]
noSort = ("question", "answer", "template", "cardGroup", "factGroup") noSort = ("question", "answer", "template", "cardGroup", "noteGroup")
if type in noSort: if type in noSort:
showInfo(_("Sorting on this column is not supported. Please " showInfo(_("Sorting on this column is not supported. Please "
"choose another.")) "choose another."))
@ -541,7 +541,7 @@ class Browser(QMainWindow):
if self.deck.conf['sortType'] != type: if self.deck.conf['sortType'] != type:
self.deck.conf['sortType'] = type self.deck.conf['sortType'] = type
# default to descending for non-text fields # default to descending for non-text fields
if type == "factFld": if type == "noteFld":
ord = not ord ord = not ord
self.deck.conf['sortBackwards'] = ord self.deck.conf['sortBackwards'] = ord
self.onSearch() self.onSearch()
@ -592,7 +592,7 @@ class Browser(QMainWindow):
def setColumnSizes(self): def setColumnSizes(self):
hh = self.form.tableView.horizontalHeader() hh = self.form.tableView.horizontalHeader()
for c, i in enumerate(self.model.activeCols): for c, i in enumerate(self.model.activeCols):
if i in ("question", "answer", "factFld"): if i in ("question", "answer", "noteFld"):
hh.setResizeMode(c, QHeaderView.Stretch) hh.setResizeMode(c, QHeaderView.Stretch)
else: else:
hh.setResizeMode(c, QHeaderView.Interactive) hh.setResizeMode(c, QHeaderView.Interactive)
@ -809,24 +809,24 @@ class Browser(QMainWindow):
return [self.model.cards[idx.row()] for idx in return [self.model.cards[idx.row()] for idx in
self.form.tableView.selectionModel().selectedRows()] self.form.tableView.selectionModel().selectedRows()]
def selectedFacts(self): def selectedNotes(self):
return self.deck.db.list(""" return self.deck.db.list("""
select distinct fid from cards select distinct nid from cards
where id in %s""" % ids2str( where id in %s""" % ids2str(
[self.model.cards[idx.row()] for idx in [self.model.cards[idx.row()] for idx in
self.form.tableView.selectionModel().selectedRows()])) self.form.tableView.selectionModel().selectedRows()]))
def selectedFactsAsCards(self): def selectedNotesAsCards(self):
return self.deck.db.list( return self.deck.db.list(
"select id from cards where fid in (%s)" % "select id from cards where nid in (%s)" %
",".join([str(s) for s in self.selectedFacts()])) ",".join([str(s) for s in self.selectedNotes()]))
def oneModelFacts(self): def oneModelNotes(self):
sf = self.selectedFacts() sf = self.selectedNotes()
if not sf: if not sf:
return return
mods = self.deck.db.scalar(""" mods = self.deck.db.scalar("""
select count(distinct mid) from facts select count(distinct mid) from notes
where id in %s""" % ids2str(sf)) where id in %s""" % ids2str(sf))
if mods > 1: if mods > 1:
showInfo(_("Please select cards from only one model.")) showInfo(_("Please select cards from only one model."))
@ -840,14 +840,14 @@ where id in %s""" % ids2str(sf))
###################################################################### ######################################################################
def genCards(self): def genCards(self):
fids = self.oneModelFacts() nids = self.oneModelNotes()
if fids: if nids:
GenCards(self, fids) GenCards(self, nids)
def onChangeModel(self): def onChangeModel(self):
fids = self.oneModelFacts() nids = self.oneModelNotes()
if fids: if nids:
ChangeModel(self, fids) ChangeModel(self, nids)
def cram(self): def cram(self):
return showInfo("not yet implemented") return showInfo("not yet implemented")
@ -900,11 +900,11 @@ where id in %s""" % ids2str(sf))
self.selectedCards()), mod, gid) self.selectedCards()), mod, gid)
if frm.setInitial.isChecked(): if frm.setInitial.isChecked():
self.deck.db.execute( self.deck.db.execute(
"update facts set mod=?, gid=? where id in " + ids2str( "update notes set mod=?, gid=? where id in " + ids2str(
self.selectedFacts()), mod, gid) self.selectedNotes()), mod, gid)
else: else:
self.deck.db.execute(""" self.deck.db.execute("""
update cards set mod=?, gid=(select gid from facts where id = cards.fid) update cards set mod=?, gid=(select gid from notes where id = cards.nid)
where id in %s""" % ids2str(self.selectedCards()), mod) where id in %s""" % ids2str(self.selectedCards()), mod)
self.onSearch(reset=False) self.onSearch(reset=False)
self.mw.requireReset() self.mw.requireReset()
@ -929,7 +929,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
label = _("Add Tags") label = _("Add Tags")
if label: if label:
self.mw.checkpoint(label) self.mw.checkpoint(label)
func(self.selectedFacts(), tags) func(self.selectedNotes(), tags)
self.onSearch(reset=False) self.onSearch(reset=False)
self.mw.requireReset() self.mw.requireReset()
self.model.endReset() self.model.endReset()
@ -962,7 +962,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
self.mw.requireReset() self.mw.requireReset()
def isMarked(self): def isMarked(self):
return not not (self.card and self.card.fact().hasTag("Marked")) return not not (self.card and self.card.note().hasTag("Marked"))
def onMark(self, mark): def onMark(self, mark):
if mark: if mark:
@ -1023,9 +1023,9 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
# Edit: selection # Edit: selection
###################################################################### ######################################################################
def selectFacts(self): def selectNotes(self):
fids = self.selectedFacts() nids = self.selectedNotes()
self.form.searchEdit.setText("fid:"+",".join([str(x) for x in fids])) self.form.searchEdit.setText("nid:"+",".join([str(x) for x in nids]))
# clear the selection so we don't waste energy preserving it # clear the selection so we don't waste energy preserving it
tv = self.form.tableView tv = self.form.tableView
tv.selectionModel().clear() tv.selectionModel().clear()
@ -1084,7 +1084,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
###################################################################### ######################################################################
def onFindReplace(self): def onFindReplace(self):
sf = self.selectedFacts() sf = self.selectedNotes()
if not sf: if not sf:
return return
import anki.find import anki.find
@ -1123,8 +1123,8 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
self.model.endReset() self.model.endReset()
self.mw.progress.finish() self.mw.progress.finish()
showInfo(ngettext( showInfo(ngettext(
"%(a)d of %(b)d fact updated", "%(a)d of %(b)d note updated",
"%(a)d of %(b)d facts updated", len(sf)) % { "%(a)d of %(b)d notes updated", len(sf)) % {
'a': changed, 'a': changed,
'b': len(sf), 'b': len(sf),
}) })
@ -1141,7 +1141,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
aqt = ankiqt.forms.finddupes.Ui_Dialog() aqt = ankiqt.forms.finddupes.Ui_Dialog()
dialog.setupUi(win) dialog.setupUi(win)
restoreGeom(win, "findDupes") restoreGeom(win, "findDupes")
fields = sorted(self.card.fact.model.fieldModels, key=attrgetter("name")) fields = sorted(self.card.note.model.fieldModels, key=attrgetter("name"))
# per-model data # per-model data
data = self.deck.db.all(""" data = self.deck.db.all("""
select fm.id, m.name || '>' || fm.name from fieldmodels fm, models m select fm.id, m.name || '>' || fm.name from fieldmodels fm, models m
@ -1196,7 +1196,7 @@ select fm.id, fm.name from fieldmodels fm""")
for group in res: for group in res:
t += '<li><a href="%s">%s</a>' % ( t += '<li><a href="%s">%s</a>' % (
"fid:" + ",".join(str(id) for id in group[1]), "nid:" + ",".join(str(id) for id in group[1]),
group[0]) group[0])
t += "</ol>" t += "</ol>"
@ -1207,7 +1207,7 @@ select fm.id, fm.name from fieldmodels fm""")
def dupeLinkClicked(self, link): def dupeLinkClicked(self, link):
self.form.searchEdit.setText(link.toString()) self.form.searchEdit.setText(link.toString())
self.onSearch() self.onSearch()
self.onFact() self.onNote()
# Jumping # Jumping
###################################################################### ######################################################################
@ -1231,7 +1231,7 @@ select fm.id, fm.name from fieldmodels fm""")
self.form.searchEdit.setFocus() self.form.searchEdit.setFocus()
self.form.searchEdit.selectAll() self.form.searchEdit.selectAll()
def onFact(self): def onNote(self):
self.editor.focus() self.editor.focus()
def onTags(self): def onTags(self):
@ -1248,10 +1248,10 @@ select fm.id, fm.name from fieldmodels fm""")
class GenCards(QDialog): class GenCards(QDialog):
def __init__(self, browser, fids): def __init__(self, browser, nids):
QDialog.__init__(self, browser) QDialog.__init__(self, browser)
self.browser = browser self.browser = browser
self.fids = fids self.nids = nids
self.form = aqt.forms.gencards.Ui_Dialog() self.form = aqt.forms.gencards.Ui_Dialog()
self.form.setupUi(self) self.form.setupUi(self)
self.setWindowModality(Qt.WindowModal) self.setWindowModality(Qt.WindowModal)
@ -1262,7 +1262,7 @@ class GenCards(QDialog):
def getSelection(self): def getSelection(self):
# get cards to enable # get cards to enable
f = self.browser.deck.getFact(self.fids[0]) f = self.browser.deck.getNote(self.nids[0])
self.model = f.model() self.model = f.model()
self.items = [] self.items = []
for t in self.model.templates: for t in self.model.templates:
@ -1296,15 +1296,15 @@ class GenCards(QDialog):
mw = self.browser.mw mw = self.browser.mw
mw.checkpoint(_("Generate Cards")) mw.checkpoint(_("Generate Cards"))
mw.progress.start() mw.progress.start()
for c, fid in enumerate(self.fids): for c, nid in enumerate(self.nids):
f = mw.deck.getFact(fid) f = mw.deck.getNote(nid)
mw.deck.genCards(f, tplates) mw.deck.genCards(f, tplates)
if c % 100 == 0: if c % 100 == 0:
mw.progress.update() mw.progress.update()
if unused: if unused:
cids = mw.deck.db.list(""" cids = mw.deck.db.list("""
select id from cards where fid in %s and ord in %s""" % ( select id from cards where nid in %s and ord in %s""" % (
ids2str(self.fids), ids2str(unused))) ids2str(self.nids), ids2str(unused)))
mw.deck.remCards(cids) mw.deck.remCards(cids)
mw.progress.finish() mw.progress.finish()
mw.requireReset() mw.requireReset()
@ -1318,11 +1318,11 @@ select id from cards where fid in %s and ord in %s""" % (
class ChangeModel(QDialog): class ChangeModel(QDialog):
def __init__(self, browser, fids): def __init__(self, browser, nids):
QDialog.__init__(self, browser) QDialog.__init__(self, browser)
self.browser = browser self.browser = browser
self.fids = fids self.nids = nids
self.oldModel = browser.card.fact().model() self.oldModel = browser.card.note().model()
self.form = aqt.forms.changemodel.Ui_Dialog() self.form = aqt.forms.changemodel.Ui_Dialog()
self.form.setupUi(self) self.form.setupUi(self)
self.setWindowModality(Qt.WindowModal) self.setWindowModality(Qt.WindowModal)
@ -1461,14 +1461,14 @@ class ChangeModel(QDialog):
if any(True for c in cmap.values() if c is None): if any(True for c in cmap.values() if c is None):
if not askUser(_("""\ if not askUser(_("""\
Any cards with templates mapped to nothing will be deleted. \ Any cards with templates mapped to nothing will be deleted. \
If a fact has no remaining cards, it will be lost. \ If a note has no remaining cards, it will be lost. \
Are you sure you want to continue?""")): Are you sure you want to continue?""")):
return return
self.browser.mw.checkpoint(_("Change Model")) self.browser.mw.checkpoint(_("Change Model"))
b = self.browser b = self.browser
b.mw.progress.start() b.mw.progress.start()
b.model.beginReset() b.model.beginReset()
self.oldModel.changeModel(self.fids, self.targetModel, fmap, cmap) self.oldModel.changeModel(self.nids, self.targetModel, fmap, cmap)
b.onSearch(reset=False) b.onSearch(reset=False)
b.model.endReset() b.model.endReset()
b.mw.progress.finish() b.mw.progress.finish()

22
aqt/clayout.py
View file

@ -20,17 +20,17 @@ class ResizingTextEdit(QTextEdit):
class CardLayout(QDialog): class CardLayout(QDialog):
# type is previewCards() type # type is previewCards() type
def __init__(self, mw, fact, type=0, ord=0, parent=None): def __init__(self, mw, note, type=0, ord=0, parent=None):
QDialog.__init__(self, parent or mw, Qt.Window) QDialog.__init__(self, parent or mw, Qt.Window)
raise Exception("Remember to disallow media&latex refs in edit.") raise Exception("Remember to disallow media&latex refs in edit.")
self.mw = aqt.mw self.mw = aqt.mw
self.parent = parent or mw self.parent = parent or mw
self.fact = fact self.note = note
self.type = type self.type = type
self.ord = ord self.ord = ord
self.deck = self.mw.deck self.deck = self.mw.deck
self.mm = self.mw.deck.models self.mm = self.mw.deck.models
self.model = fact.model() self.model = note.model()
self.form = aqt.forms.clayout.Ui_Dialog() self.form = aqt.forms.clayout.Ui_Dialog()
self.form.setupUi(self) self.form.setupUi(self)
self.setWindowTitle(_("%s Layout") % self.model['name']) self.setWindowTitle(_("%s Layout") % self.model['name'])
@ -50,13 +50,13 @@ class CardLayout(QDialog):
self.exec_() self.exec_()
def reload(self, first=False): def reload(self, first=False):
self.cards = self.deck.previewCards(self.fact, self.type) self.cards = self.deck.previewCards(self.note, self.type)
if not self.cards: if not self.cards:
self.accept() self.accept()
if first: if first:
showInfo(_("Please enter some text first.")) showInfo(_("Please enter some text first."))
else: else:
showInfo(_("The current fact was deleted.")) showInfo(_("The current note was deleted."))
return return
self.fillCardList() self.fillCardList()
self.fillFieldList() self.fillFieldList()
@ -76,7 +76,7 @@ class CardLayout(QDialog):
_("Templates that will be created:")) _("Templates that will be created:"))
elif self.type == 1: elif self.type == 1:
f.templateType.setText( f.templateType.setText(
_("Templates used by fact:")) _("Templates used by note:"))
else: else:
f.templateType.setText( f.templateType.setText(
_("All templates:")) _("All templates:"))
@ -259,10 +259,10 @@ class CardLayout(QDialog):
if self.needFieldRebuild: if self.needFieldRebuild:
modified = True modified = True
if modified: if modified:
self.fact.model.setModified() self.note.model.setModified()
self.deck.flushMod() self.deck.flushMod()
if self.factedit and self.factedit.onChange: if self.noteedit and self.noteedit.onChange:
self.factedit.onChange("all") self.noteedit.onChange("all")
reset=False reset=False
if reset: if reset:
self.mw.reset() self.mw.reset()
@ -358,7 +358,7 @@ class CardLayout(QDialog):
if fld['name'] != name: if fld['name'] != name:
self.mm.renameField(self.model, fld, name) self.mm.renameField(self.model, fld, name)
# as the field name has changed, we have to regenerate cards # as the field name has changed, we have to regenerate cards
self.cards = self.deck.previewCards(self.fact, self.type) self.cards = self.deck.previewCards(self.note, self.type)
self.cardChanged(0) self.cardChanged(0)
self.renderPreview() self.renderPreview()
self.fillFieldList() self.fillFieldList()
@ -413,7 +413,7 @@ class CardLayout(QDialog):
if len(self.model.fields) < 2: if len(self.model.fields) < 2:
showInfo(_("Please add a new field first.")) showInfo(_("Please add a new field first."))
return return
if askUser(_("Delete this field and its data from all facts?")): if askUser(_("Delete this field and its data from all notes?")):
self.mw.progress.start() self.mw.progress.start()
self.model.delField(self.field) self.model.delField(self.field)
self.mw.progress.finish() self.mw.progress.finish()

4
aqt/editcurrent.py
View file

@ -24,7 +24,7 @@ class EditCurrent(QDialog):
SIGNAL("rejected()"), SIGNAL("rejected()"),
self.onSave) self.onSave)
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea) self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea)
self.editor.setFact(self.mw.reviewer.card.fact()) self.editor.setNote(self.mw.reviewer.card.note())
restoreGeom(self, "editcurrent") restoreGeom(self, "editcurrent")
addHook("closeEditCurrent", self.onSave) addHook("closeEditCurrent", self.onSave)
self.mw.requireReset(modal=True) self.mw.requireReset(modal=True)
@ -35,7 +35,7 @@ class EditCurrent(QDialog):
def onSave(self): def onSave(self):
removeHook("closeEditCurrent", self.onSave) removeHook("closeEditCurrent", self.onSave)
self.editor.saveNow() self.editor.saveNow()
self.editor.setFact(None) self.editor.setNote(None)
r = self.mw.reviewer r = self.mw.reviewer
r.card.load() r.card.load()
r.keep = True r.keep = True

88
aqt/editor.py
View file

@ -188,12 +188,12 @@ $(function () {
</body></html> </body></html>
""" """
# caller is responsible for resetting fact on reset # caller is responsible for resetting note on reset
class Editor(object): class Editor(object):
def __init__(self, mw, widget, addMode=False): def __init__(self, mw, widget, addMode=False):
self.widget = widget self.widget = widget
self.mw = mw self.mw = mw
self.fact = None self.note = None
self.stealFocus = True self.stealFocus = True
self.addMode = addMode self.addMode = addMode
self._loaded = False self._loaded = False
@ -311,28 +311,28 @@ class Editor(object):
type = 1; ord = self.card.ord type = 1; ord = self.card.ord
else: else:
type = 0; ord = 0 type = 0; ord = 0
CardLayout(self.mw, self.fact, type=type, ord=ord, parent=self.widget) CardLayout(self.mw, self.note, type=type, ord=ord, parent=self.widget)
self.loadFact() self.loadNote()
# JS->Python bridge # JS->Python bridge
###################################################################### ######################################################################
def bridge(self, str): def bridge(self, str):
if not self.fact or not runHook: if not self.note or not runHook:
# shutdown # shutdown
return return
# focus lost or key/button pressed? # focus lost or key/button pressed?
if str.startswith("blur") or str.startswith("key"): if str.startswith("blur") or str.startswith("key"):
(type, txt) = str.split(":", 1) (type, txt) = str.split(":", 1)
self.fact.fields[self.currentField] = self.mungeHTML(txt) self.note.fields[self.currentField] = self.mungeHTML(txt)
self.mw.requireReset() self.mw.requireReset()
self.fact.flush() self.note.flush()
if type == "blur": if type == "blur":
if not self._keepButtons: if not self._keepButtons:
self.disableButtons() self.disableButtons()
runHook("editFocusLost", self.fact) runHook("editFocusLost", self.note)
else: else:
runHook("editTimer", self.fact) runHook("editTimer", self.note)
self.checkValid() self.checkValid()
# focused into field? # focused into field?
elif str.startswith("focus"): elif str.startswith("focus"):
@ -358,19 +358,19 @@ class Editor(object):
txt = "" txt = ""
return txt return txt
# Setting/unsetting the current fact # Setting/unsetting the current note
###################################################################### ######################################################################
def _loadFinished(self, w): def _loadFinished(self, w):
self._loaded = True self._loaded = True
if self.fact: if self.note:
self.loadFact() self.loadNote()
def setFact(self, fact, hide=True): def setNote(self, note, hide=True):
"Make FACT the current fact." "Make NOTE the current note."
self.fact = fact self.note = note
# change timer # change timer
if self.fact: if self.note:
self.web.setHtml(_html % (getBase(self.mw.deck), anki.js.all, self.web.setHtml(_html % (getBase(self.mw.deck), anki.js.all,
_("Show Duplicates")), _("Show Duplicates")),
loadCB=self._loadFinished) loadCB=self._loadFinished)
@ -379,12 +379,12 @@ class Editor(object):
elif hide: elif hide:
self.widget.hide() self.widget.hide()
def loadFact(self, field=0): def loadNote(self, field=0):
if not self._loaded: if not self._loaded:
# will be loaded when page is ready # will be loaded when page is ready
return return
self.web.eval("setFields(%s, %d);" % ( self.web.eval("setFields(%s, %d);" % (
simplejson.dumps(self.fact.items()), field)) simplejson.dumps(self.note.items()), field))
self.web.eval("setFonts(%s);" % ( self.web.eval("setFonts(%s);" % (
simplejson.dumps(self.fonts()))) simplejson.dumps(self.fonts())))
self.checkValid() self.checkValid()
@ -397,11 +397,11 @@ class Editor(object):
def fonts(self): def fonts(self):
return [(f['font'], f['esize']) return [(f['font'], f['esize'])
for f in self.fact.model()['flds']] for f in self.note.model()['flds']]
def saveNow(self): def saveNow(self):
"Must call this before adding cards, closing dialog, etc." "Must call this before adding cards, closing dialog, etc."
if not self.fact: if not self.note:
return return
self._keepButtons = True self._keepButtons = True
self.web.eval("saveField('blur');") self.web.eval("saveField('blur');")
@ -411,7 +411,7 @@ class Editor(object):
def checkValid(self): def checkValid(self):
cols = [] cols = []
self.dupe = None self.dupe = None
for c, p in enumerate(self.fact.problems()): for c, p in enumerate(self.note.problems()):
if not p: if not p:
cols.append("#fff") cols.append("#fff")
elif p == "unique": elif p == "unique":
@ -426,16 +426,16 @@ class Editor(object):
self.web.eval("hideDupes();") self.web.eval("hideDupes();")
def showDupes(self): def showDupes(self):
contents = self.fact.fields[self.dupe] contents = self.note.fields[self.dupe]
browser = aqt.dialogs.open("Browser", self.mw) browser = aqt.dialogs.open("Browser", self.mw)
browser.form.searchEdit.setText( browser.form.searchEdit.setText(
"'model:%s' '%s'" % (self.fact.model().name, contents)) "'model:%s' '%s'" % (self.note.model().name, contents))
browser.onSearch() browser.onSearch()
def fieldsAreBlank(self): def fieldsAreBlank(self):
if not self.fact: if not self.note:
return True return True
for f in self.fact.fields: for f in self.note.fields:
if f: if f:
return False return False
return True return True
@ -450,12 +450,12 @@ class Editor(object):
form.setupUi(d) form.setupUi(d)
d.connect(form.buttonBox, SIGNAL("helpRequested()"), d.connect(form.buttonBox, SIGNAL("helpRequested()"),
lambda: aqt.openHelp("HtmlEditor")) lambda: aqt.openHelp("HtmlEditor"))
form.textEdit.setPlainText(self.fact.fields[self.currentField]) form.textEdit.setPlainText(self.note.fields[self.currentField])
form.textEdit.moveCursor(QTextCursor.End) form.textEdit.moveCursor(QTextCursor.End)
d.exec_() d.exec_()
self.fact.fields[self.currentField] = unicode( self.note.fields[self.currentField] = unicode(
form.textEdit.toPlainText()) form.textEdit.toPlainText())
self.loadFact(self.currentField) self.loadNote(self.currentField)
# Tag and group handling # Tag and group handling
###################################################################### ######################################################################
@ -494,32 +494,32 @@ class Editor(object):
self.tags.setDeck(self.mw.deck) self.tags.setDeck(self.mw.deck)
if self.addMode: if self.addMode:
self.group.setDeck(self.mw.deck) self.group.setDeck(self.mw.deck)
self.tags.setText(self.fact.stringTags().strip()) self.tags.setText(self.note.stringTags().strip())
if getattr(self.fact, 'gid', None): if getattr(self.note, 'gid', None):
gid = self.fact.gid gid = self.note.gid
else: else:
gid = self.fact.model().conf['gid'] gid = self.note.model().conf['gid']
self.group.setText(self.mw.deck.groups.name(gid)) self.group.setText(self.mw.deck.groups.name(gid))
def saveTagsAndGroup(self): def saveTagsAndGroup(self):
if not self.fact: if not self.note:
return return
self.fact.tags = self.mw.deck.tags.split(unicode(self.tags.text())) self.note.tags = self.mw.deck.tags.split(unicode(self.tags.text()))
if self.addMode: if self.addMode:
# save group and tags to model # save group and tags to model
self.fact.gid = self.mw.deck.groups.id(unicode(self.group.text())) self.note.gid = self.mw.deck.groups.id(unicode(self.group.text()))
m = self.fact.model() m = self.note.model()
m['gid'] = self.fact.gid m['gid'] = self.note.gid
m['tags'] = self.fact.tags m['tags'] = self.note.tags
self.mw.deck.models.save(m) self.mw.deck.models.save(m)
self.fact.flush() self.note.flush()
runHook("tagsAndGroupUpdated", self.fact) runHook("tagsAndGroupUpdated", self.note)
def changeGroup(self): def changeGroup(self):
id = self.fact.id id = self.note.id
runHook("closeEditCurrent") runHook("closeEditCurrent")
browser = aqt.dialogs.open("Browser", self.mw) browser = aqt.dialogs.open("Browser", self.mw)
browser.form.searchEdit.setText("fid:%d" % id) browser.form.searchEdit.setText("nid:%d" % id)
browser.onSearch() browser.onSearch()
browser.setGroup(True) browser.setGroup(True)
@ -547,7 +547,7 @@ class Editor(object):
def onCloze(self): def onCloze(self):
# check that the model is set up for cloze deletion # check that the model is set up for cloze deletion
ok = False ok = False
for t in self.fact.model().templates: for t in self.note.model().templates:
if "cloze" in t['qfmt'] or "cloze" in t['afmt']: if "cloze" in t['qfmt'] or "cloze" in t['afmt']:
ok = True ok = True
break break
@ -555,7 +555,7 @@ class Editor(object):
showInfo(_("Please use a cloze deletion model."), showInfo(_("Please use a cloze deletion model."),
help="ClozeDeletion") help="ClozeDeletion")
return return
f = self.fact.fields[self.currentField] f = self.note.fields[self.currentField]
# find the highest existing cloze # find the highest existing cloze
m = re.findall("\{\{c(\d+)::", f) m = re.findall("\{\{c(\d+)::", f)
if m: if m:

2
aqt/importing.py
View file

@ -214,7 +214,7 @@ you can enter it here. Use \\t to represent tab."""),
self.parent.deck.finishProgress() self.parent.deck.finishProgress()
self.parent.deck.setUndoEnd(n) self.parent.deck.setUndoEnd(n)
txt = ( txt = (
_("Importing complete. %(num)d facts imported from %(file)s.\n") % _("Importing complete. %(num)d notes imported from %(file)s.\n") %
{"num": self.importer.total, "file": os.path.basename(self.file)}) {"num": self.importer.total, "file": os.path.basename(self.file)})
self.dialog.groupBox.setShown(False) self.dialog.groupBox.setShown(False)
self.dialog.buttonBox.button(QDialogButtonBox.Close).setFocus() self.dialog.buttonBox.button(QDialogButtonBox.Close).setFocus()

24
aqt/main.py
View file

@ -123,9 +123,9 @@ class AnkiQt(QMainWindow):
def _editCurrentState(self, oldState): def _editCurrentState(self, oldState):
pass pass
def factChanged(self, fid): def noteChanged(self, nid):
"Called when a card or fact is edited (but not deleted)." "Called when a card or note is edited (but not deleted)."
runHook("factChanged", fid) runHook("noteChanged", nid)
# Resetting state # Resetting state
########################################################################## ##########################################################################
@ -541,7 +541,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
def closeEvent(self, event): def closeEvent(self, event):
"User hit the X button, etc." "User hit the X button, etc."
print "fixme: exit from edit current, review, etc" print "fixme: exit from edit current, review, etc"
if self.state == "editCurrentFact": if self.state == "editCurrentNote":
event.ignore() event.ignore()
return self.moveToState("saveEdit") return self.moveToState("saveEdit")
self.close(showBrowser=False) self.close(showBrowser=False)
@ -602,11 +602,11 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
def updateMarkAction(self, ): def updateMarkAction(self, ):
self.form.actionMarkCard.blockSignals(True) self.form.actionMarkCard.blockSignals(True)
self.form.actionMarkCard.setChecked( self.form.actionMarkCard.setChecked(
self.reviewer.card.fact().hasTag("marked")) self.reviewer.card.note().hasTag("marked"))
self.form.actionMarkCard.blockSignals(False) self.form.actionMarkCard.blockSignals(False)
def onMark(self, toggled): def onMark(self, toggled):
f = self.reviewer.card.fact() f = self.reviewer.card.note()
if f.hasTag("marked"): if f.hasTag("marked"):
f.delTag("marked") f.delTag("marked")
else: else:
@ -623,9 +623,9 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
self.deck.remCards([self.reviewer.card.id]) self.deck.remCards([self.reviewer.card.id])
self.reviewer.nextCard() self.reviewer.nextCard()
def onBuryFact(self): def onBuryNote(self):
self.checkpoint(_("Bury")) self.checkpoint(_("Bury"))
self.deck.sched.buryFact(self.reviewer.card.fid) self.deck.sched.buryNote(self.reviewer.card.nid)
self.reviewer.nextCard() self.reviewer.nextCard()
# Undo & autosave # Undo & autosave
@ -690,7 +690,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
def onCardLayout(self): def onCardLayout(self):
from aqt.clayout import CardLayout from aqt.clayout import CardLayout
CardLayout(self, self.reviewer.card.fact(), type=1, CardLayout(self, self.reviewer.card.note(), type=1,
ord=self.reviewer.card.ord) ord=self.reviewer.card.ord)
def onDeckOpts(self): def onDeckOpts(self):
@ -829,7 +829,7 @@ Please choose a new deck name:"""))
self.connect(m.actionGroups, s, self.onGroups) self.connect(m.actionGroups, s, self.onGroups)
self.connect(m.actionDocumentation, s, self.onDocumentation) self.connect(m.actionDocumentation, s, self.onDocumentation)
self.connect(m.actionDonate, s, self.onDonate) self.connect(m.actionDonate, s, self.onDonate)
self.connect(m.actionBuryFact, s, self.onBuryFact) self.connect(m.actionBuryNote, s, self.onBuryNote)
def enableDeckMenuItems(self, enabled=True): def enableDeckMenuItems(self, enabled=True):
"setEnabled deck-related items." "setEnabled deck-related items."
@ -855,7 +855,7 @@ Please choose a new deck name:"""))
self.form.actionMarkCard.setEnabled(False) self.form.actionMarkCard.setEnabled(False)
self.form.actionSuspendCard.setEnabled(False) self.form.actionSuspendCard.setEnabled(False)
self.form.actionDelete.setEnabled(False) self.form.actionDelete.setEnabled(False)
self.form.actionBuryFact.setEnabled(False) self.form.actionBuryNote.setEnabled(False)
self.form.actionRepeatAudio.setEnabled(False) self.form.actionRepeatAudio.setEnabled(False)
runHook("disableCardMenuItems") runHook("disableCardMenuItems")
@ -865,7 +865,7 @@ Please choose a new deck name:"""))
self.form.actionMarkCard.setEnabled(True) self.form.actionMarkCard.setEnabled(True)
self.form.actionSuspendCard.setEnabled(True) self.form.actionSuspendCard.setEnabled(True)
self.form.actionDelete.setEnabled(True) self.form.actionDelete.setEnabled(True)
self.form.actionBuryFact.setEnabled(True) self.form.actionBuryNote.setEnabled(True)
self.form.actionEditCurrent.setEnabled(True) self.form.actionEditCurrent.setEnabled(True)
self.form.actionEditdeck.setEnabled(True) self.form.actionEditdeck.setEnabled(True)
self.updateMarkAction() self.updateMarkAction()

22
aqt/models.py
View file

@ -59,8 +59,8 @@ class Models(QDialog):
self.models = [self.deck.getModel(mid) for mid in mids] self.models = [self.deck.getModel(mid) for mid in mids]
self.form.modelsList.clear() self.form.modelsList.clear()
for m in self.models: for m in self.models:
item = QListWidgetItem(_("%(name)s [%(facts)d facts]") % dict( item = QListWidgetItem(_("%(name)s [%(notes)d notes]") % dict(
name=m.name, facts=m.useCount())) name=m.name, notes=m.useCount()))
self.form.modelsList.addItem(item) self.form.modelsList.addItem(item)
self.form.modelsList.setCurrentRow(row) self.form.modelsList.setCurrentRow(row)
@ -78,23 +78,23 @@ class Models(QDialog):
def onLayout(self): def onLayout(self):
# set to current # set to current
# # see if there's an available fact # # see if there's an available note
dummy = False dummy = False
id = self.deck.db.scalar( id = self.deck.db.scalar(
"select id from facts where mid = ?", self.model.id) "select id from notes where mid = ?", self.model.id)
if id: if id:
fact = self.deck.getFact(id) note = self.deck.getNote(id)
else: else:
# generate a dummy one # generate a dummy one
self.deck.conf['currentModelId'] = self.model.id self.deck.conf['currentModelId'] = self.model.id
fact = self.deck.newFact() note = self.deck.newNote()
for f in fact.keys(): for f in note.keys():
fact[f] = f note[f] = f
self.deck.addFact(fact) self.deck.addNote(note)
dummy = True dummy = True
aqt.clayout.CardLayout(self.mw, fact, type=2, parent=self) aqt.clayout.CardLayout(self.mw, note, type=2, parent=self)
if dummy: if dummy:
self.deck._delFacts([fact.id]) self.deck._delNotes([note.id])
def onDelete(self): def onDelete(self):
if len(self.models) < 2: if len(self.models) < 2:

2
aqt/reviewer.py
View file

@ -402,7 +402,7 @@ div#filler {
ord = self.typeAns() ord = self.typeAns()
try: try:
cor = self.mw.deck.media.strip( cor = self.mw.deck.media.strip(
stripHTML(self.card.fact().fields[ord])) stripHTML(self.card.note().fields[ord]))
except IndexError: except IndexError:
self.card.template()['typeAns'] = None self.card.template()['typeAns'] = None
self.card.model().flush() self.card.model().flush()

4
aqt/share.py
View file

@ -54,14 +54,14 @@
self.deck.updateProgress() self.deck.updateProgress()
d.s.statement("vacuum") d.s.statement("vacuum")
self.deck.updateProgress() self.deck.updateProgress()
nfacts = d.factCount nnotes = d.noteCount
mdir = self.deck.mediaDir() mdir = self.deck.mediaDir()
d.close() d.close()
dir = os.path.dirname(path) dir = os.path.dirname(path)
zippath = os.path.join(dir, "shared-%d.zip" % time.time()) zippath = os.path.join(dir, "shared-%d.zip" % time.time())
# zip it up # zip it up
zip = zipfile.ZipFile(zippath, "w", zipfile.ZIP_DEFLATED) zip = zipfile.ZipFile(zippath, "w", zipfile.ZIP_DEFLATED)
zip.writestr("facts", str(nfacts)) zip.writestr("notes", str(nnotes))
zip.writestr("version", str(2)) zip.writestr("version", str(2))
readmep = os.path.join(dir, "README.html") readmep = os.path.join(dir, "README.html")
readme = open(readmep, "w") readme = open(readmep, "w")

4
aqt/sync.py
View file

@ -388,8 +388,8 @@ firewall software temporarily, or try again from a different network.
Debugging info: %s""") % error.data.get("exc", "<none>") Debugging info: %s""") % error.data.get("exc", "<none>")
else: else:
tb = traceback.format_exc() tb = traceback.format_exc()
if "missingFacts" in tb: if "missingNotes" in tb:
msg=_("""Facts were missing after sync, so the \ msg=_("""Notes were missing after sync, so the \
sync was aborted. Please report this error.""") sync was aborted. Please report this error.""")
else: else:
msg=_("Unknown error: %s") % tb msg=_("Unknown error: %s") % tb