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
1854 lines
64 KiB
Python
1854 lines
64 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 sre_constants
|
|
import cgi
|
|
import time
|
|
import re
|
|
from operator import itemgetter
|
|
from anki.lang import ngettext
|
|
import json
|
|
|
|
from aqt.qt import *
|
|
import anki
|
|
import aqt.forms
|
|
from anki.utils import fmtTimeSpan, ids2str, stripHTMLMedia, htmlToTextLine, isWin, intTime,\
|
|
isMac, isLin
|
|
from aqt.utils import saveGeom, restoreGeom, saveSplitter, restoreSplitter, \
|
|
saveHeader, restoreHeader, saveState, restoreState, applyStyles, getTag, \
|
|
showInfo, askUser, tooltip, openHelp, showWarning, shortcut, mungeQA, \
|
|
getOnlyText
|
|
from anki.hooks import runHook, addHook, remHook
|
|
from aqt.webview import AnkiWebView
|
|
from anki.consts import *
|
|
from anki.sound import playFromText, clearAudioQueue
|
|
|
|
# Data model
|
|
##########################################################################
|
|
|
|
class DataModel(QAbstractTableModel):
|
|
|
|
def __init__(self, browser):
|
|
QAbstractTableModel.__init__(self)
|
|
self.browser = browser
|
|
self.col = browser.col
|
|
self.sortKey = None
|
|
self.activeCols = self.col.conf.get(
|
|
"activeCols", ["noteFld", "template", "cardDue", "deck"])
|
|
self.cards = []
|
|
self.cardObjs = {}
|
|
|
|
def getCard(self, index):
|
|
id = self.cards[index.row()]
|
|
if not id in self.cardObjs:
|
|
self.cardObjs[id] = self.col.getCard(id)
|
|
return self.cardObjs[id]
|
|
|
|
def refreshNote(self, note):
|
|
refresh = False
|
|
for c in note.cards():
|
|
if c.id in self.cardObjs:
|
|
del self.cardObjs[c.id]
|
|
refresh = True
|
|
if refresh:
|
|
self.layoutChanged.emit()
|
|
|
|
# Model interface
|
|
######################################################################
|
|
|
|
def rowCount(self, parent):
|
|
if parent and parent.isValid():
|
|
return 0
|
|
return len(self.cards)
|
|
|
|
def columnCount(self, parent):
|
|
if parent and parent.isValid():
|
|
return 0
|
|
return len(self.activeCols)
|
|
|
|
def data(self, index, role):
|
|
if not index.isValid():
|
|
return
|
|
if role == Qt.FontRole:
|
|
if self.activeCols[index.column()] not in (
|
|
"question", "answer", "noteFld"):
|
|
return
|
|
row = index.row()
|
|
c = self.getCard(index)
|
|
t = c.template()
|
|
if not t.get("bfont"):
|
|
return
|
|
f = QFont()
|
|
f.setFamily(t.get("bfont", "arial"))
|
|
f.setPixelSize(t.get("bsize", 12))
|
|
return f
|
|
|
|
elif role == Qt.TextAlignmentRole:
|
|
align = Qt.AlignVCenter
|
|
if self.activeCols[index.column()] not in ("question", "answer",
|
|
"template", "deck", "noteFld", "note"):
|
|
align |= Qt.AlignHCenter
|
|
return align
|
|
elif role == Qt.DisplayRole or role == Qt.EditRole:
|
|
return self.columnData(index)
|
|
else:
|
|
return
|
|
|
|
def headerData(self, section, orientation, role):
|
|
if orientation == Qt.Vertical:
|
|
return
|
|
elif role == Qt.DisplayRole and section < len(self.activeCols):
|
|
type = self.columnType(section)
|
|
txt = None
|
|
for stype, name in self.browser.columns:
|
|
if type == stype:
|
|
txt = name
|
|
break
|
|
# handle case where extension has set an invalid column type
|
|
if not txt:
|
|
txt = self.browser.columns[0][1]
|
|
return txt
|
|
else:
|
|
return
|
|
|
|
def flags(self, index):
|
|
return Qt.ItemFlag(Qt.ItemIsEnabled |
|
|
Qt.ItemIsSelectable)
|
|
|
|
# Filtering
|
|
######################################################################
|
|
|
|
def search(self, txt):
|
|
self.beginReset()
|
|
t = time.time()
|
|
# the db progress handler may cause a refresh, so we need to zero out
|
|
# old data first
|
|
self.cards = []
|
|
invalid = False
|
|
try:
|
|
self.cards = self.col.findCards(txt, order=True)
|
|
except Exception as e:
|
|
if str(e) == "invalidSearch":
|
|
self.cards = []
|
|
invalid = True
|
|
else:
|
|
raise
|
|
#print "fetch cards in %dms" % ((time.time() - t)*1000)
|
|
self.endReset()
|
|
|
|
if invalid:
|
|
showWarning(_("Invalid search - please check for typing mistakes."))
|
|
|
|
|
|
def reset(self):
|
|
self.beginReset()
|
|
self.endReset()
|
|
|
|
# caller must have called editor.saveNow() before calling this or .reset()
|
|
def beginReset(self):
|
|
self.browser.editor.setNote(None, hide=False)
|
|
self.browser.mw.progress.start()
|
|
self.saveSelection()
|
|
self.beginResetModel()
|
|
self.cardObjs = {}
|
|
|
|
def endReset(self):
|
|
t = time.time()
|
|
self.endResetModel()
|
|
self.restoreSelection()
|
|
self.browser.mw.progress.finish()
|
|
|
|
def reverse(self):
|
|
self.browser.editor.saveNow(self._reverse)
|
|
|
|
def _reverse(self):
|
|
self.beginReset()
|
|
self.cards.reverse()
|
|
self.endReset()
|
|
|
|
def saveSelection(self):
|
|
cards = self.browser.selectedCards()
|
|
self.selectedCards = dict([(id, True) for id in cards])
|
|
if getattr(self.browser, 'card', None):
|
|
self.focusedCard = self.browser.card.id
|
|
else:
|
|
self.focusedCard = None
|
|
|
|
def restoreSelection(self):
|
|
if not self.cards:
|
|
return
|
|
sm = self.browser.form.tableView.selectionModel()
|
|
sm.clear()
|
|
# restore selection
|
|
items = QItemSelection()
|
|
count = 0
|
|
firstIdx = None
|
|
focusedIdx = None
|
|
for row, id in enumerate(self.cards):
|
|
# if the id matches the focused card, note the index
|
|
if self.focusedCard == id:
|
|
focusedIdx = self.index(row, 0)
|
|
items.select(focusedIdx, focusedIdx)
|
|
self.focusedCard = None
|
|
# if the card was previously selected, select again
|
|
if id in self.selectedCards:
|
|
count += 1
|
|
idx = self.index(row, 0)
|
|
items.select(idx, idx)
|
|
# note down the first card of the selection, in case we don't
|
|
# have a focused card
|
|
if not firstIdx:
|
|
firstIdx = idx
|
|
# focus previously focused or first in selection
|
|
idx = focusedIdx or firstIdx
|
|
tv = self.browser.form.tableView
|
|
if idx:
|
|
tv.selectRow(idx.row())
|
|
# we save and then restore the horizontal scroll position because
|
|
# scrollTo() also scrolls horizontally which is confusing
|
|
h = tv.horizontalScrollBar().value()
|
|
tv.scrollTo(idx, tv.PositionAtCenter)
|
|
tv.horizontalScrollBar().setValue(h)
|
|
if count < 500:
|
|
# discard large selections; they're too slow
|
|
sm.select(items, QItemSelectionModel.SelectCurrent |
|
|
QItemSelectionModel.Rows)
|
|
else:
|
|
tv.selectRow(0)
|
|
|
|
# Column data
|
|
######################################################################
|
|
|
|
def columnType(self, column):
|
|
return self.activeCols[column]
|
|
|
|
def columnData(self, index):
|
|
row = index.row()
|
|
col = index.column()
|
|
type = self.columnType(col)
|
|
c = self.getCard(index)
|
|
if type == "question":
|
|
return self.question(c)
|
|
elif type == "answer":
|
|
return self.answer(c)
|
|
elif type == "noteFld":
|
|
f = c.note()
|
|
return htmlToTextLine(f.fields[self.col.models.sortIdx(f.model())])
|
|
elif type == "template":
|
|
t = c.template()['name']
|
|
if c.model()['type'] == MODEL_CLOZE:
|
|
t += " %d" % (c.ord+1)
|
|
return t
|
|
elif type == "cardDue":
|
|
# catch invalid dates
|
|
try:
|
|
t = self.nextDue(c, index)
|
|
except:
|
|
t = ""
|
|
if c.queue < 0:
|
|
t = "(" + t + ")"
|
|
return t
|
|
elif type == "noteCrt":
|
|
return time.strftime("%Y-%m-%d", time.localtime(c.note().id/1000))
|
|
elif type == "noteMod":
|
|
return time.strftime("%Y-%m-%d", time.localtime(c.note().mod))
|
|
elif type == "cardMod":
|
|
return time.strftime("%Y-%m-%d", time.localtime(c.mod))
|
|
elif type == "cardReps":
|
|
return str(c.reps)
|
|
elif type == "cardLapses":
|
|
return str(c.lapses)
|
|
elif type == "noteTags":
|
|
return " ".join(c.note().tags)
|
|
elif type == "note":
|
|
return c.model()['name']
|
|
elif type == "cardIvl":
|
|
if c.type == 0:
|
|
return _("(new)")
|
|
elif c.type == 1:
|
|
return _("(learning)")
|
|
return fmtTimeSpan(c.ivl*86400)
|
|
elif type == "cardEase":
|
|
if c.type == 0:
|
|
return _("(new)")
|
|
return "%d%%" % (c.factor/10)
|
|
elif type == "deck":
|
|
if c.odid:
|
|
# in a cram deck
|
|
return "%s (%s)" % (
|
|
self.browser.mw.col.decks.name(c.did),
|
|
self.browser.mw.col.decks.name(c.odid))
|
|
# normal deck
|
|
return self.browser.mw.col.decks.name(c.did)
|
|
|
|
def question(self, c):
|
|
return htmlToTextLine(c.q(browser=True))
|
|
|
|
def answer(self, c):
|
|
if c.template().get('bafmt'):
|
|
# they have provided a template, use it verbatim
|
|
c.q(browser=True)
|
|
return htmlToTextLine(c.a())
|
|
# need to strip question from answer
|
|
q = self.question(c)
|
|
a = htmlToTextLine(c.a())
|
|
if a.startswith(q):
|
|
return a[len(q):].strip()
|
|
return a
|
|
|
|
def nextDue(self, c, index):
|
|
if c.odid:
|
|
return _("(filtered)")
|
|
elif c.queue == 1:
|
|
date = c.due
|
|
elif c.queue == 0 or c.type == 0:
|
|
return str(c.due)
|
|
elif c.queue in (2,3) or (c.type == 2 and c.queue < 0):
|
|
date = time.time() + ((c.due - self.col.sched.today)*86400)
|
|
else:
|
|
return ""
|
|
return time.strftime("%Y-%m-%d", time.localtime(date))
|
|
|
|
# Line painter
|
|
######################################################################
|
|
|
|
COLOUR_SUSPENDED = "#FFFFB2"
|
|
|
|
flagColours = {
|
|
1: "#F5B7B1",
|
|
2: "#BB8FCE",
|
|
3: "#82E0AA",
|
|
4: "#85C1E9",
|
|
}
|
|
|
|
class StatusDelegate(QItemDelegate):
|
|
|
|
def __init__(self, browser, model):
|
|
QItemDelegate.__init__(self, browser)
|
|
self.browser = browser
|
|
self.model = model
|
|
|
|
def paint(self, painter, option, index):
|
|
self.browser.mw.progress.blockUpdates = True
|
|
try:
|
|
c = self.model.getCard(index)
|
|
except:
|
|
# in the the middle of a reset; return nothing so this row is not
|
|
# rendered until we have a chance to reset the model
|
|
return
|
|
finally:
|
|
self.browser.mw.progress.blockUpdates = True
|
|
|
|
col = None
|
|
if c.queue == -1:
|
|
col = COLOUR_SUSPENDED
|
|
elif c.userFlag() > 0:
|
|
col = flagColours[c.userFlag()]
|
|
|
|
if col:
|
|
brush = QBrush(QColor(col))
|
|
painter.save()
|
|
painter.fillRect(option.rect, brush)
|
|
painter.restore()
|
|
|
|
return QItemDelegate.paint(self, painter, option, index)
|
|
|
|
# Browser window
|
|
######################################################################
|
|
|
|
# fixme: respond to reset+edit hooks
|
|
|
|
class Browser(QMainWindow):
|
|
|
|
def __init__(self, mw):
|
|
QMainWindow.__init__(self, None, Qt.Window)
|
|
applyStyles(self)
|
|
self.mw = mw
|
|
self.col = self.mw.col
|
|
self.forceClose = False
|
|
self.lastFilter = ""
|
|
self.focusTo = None
|
|
self._previewWindow = None
|
|
self._closeEventHasCleanedUp = False
|
|
self.form = aqt.forms.browser.Ui_Dialog()
|
|
self.form.setupUi(self)
|
|
restoreGeom(self, "editor", 0)
|
|
restoreState(self, "editor")
|
|
restoreSplitter(self.form.splitter, "editor3")
|
|
self.form.splitter.setChildrenCollapsible(False)
|
|
self.card = None
|
|
self.setupColumns()
|
|
self.setupTable()
|
|
self.setupMenus()
|
|
self.setupHeaders()
|
|
self.setupHooks()
|
|
self.setupEditor()
|
|
self.updateFont()
|
|
self.onUndoState(self.mw.form.actionUndo.isEnabled())
|
|
self.setupSearch()
|
|
self.show()
|
|
|
|
def setupMenus(self):
|
|
# actions
|
|
f = self.form
|
|
f.previewButton.clicked.connect(self.onTogglePreview)
|
|
f.previewButton.setToolTip(_("Preview Selected Card (%s)") %
|
|
shortcut(_("Ctrl+Shift+P")))
|
|
|
|
f.filter.clicked.connect(self.onFilterButton)
|
|
# edit
|
|
f.actionUndo.triggered.connect(self.mw.onUndo)
|
|
f.actionInvertSelection.triggered.connect(self.invertSelection)
|
|
f.actionSelectNotes.triggered.connect(self.selectNotes)
|
|
if not isMac:
|
|
f.actionClose.setVisible(False)
|
|
# notes
|
|
f.actionAdd.triggered.connect(self.mw.onAddCard)
|
|
f.actionAdd_Tags.triggered.connect(lambda: self.addTags())
|
|
f.actionRemove_Tags.triggered.connect(lambda: self.deleteTags())
|
|
f.actionChangeModel.triggered.connect(self.onChangeModel)
|
|
f.actionFindDuplicates.triggered.connect(self.onFindDupes)
|
|
f.actionFindReplace.triggered.connect(self.onFindReplace)
|
|
f.actionDelete.triggered.connect(self.deleteNotes)
|
|
# cards
|
|
f.actionChange_Deck.triggered.connect(self.setDeck)
|
|
f.action_Info.triggered.connect(self.showCardInfo)
|
|
f.actionReposition.triggered.connect(self.reposition)
|
|
f.actionReschedule.triggered.connect(self.reschedule)
|
|
f.actionToggle_Suspend.triggered.connect(self.onSuspend)
|
|
f.actionRed_Flag.triggered.connect(lambda: self.onSetFlag(1))
|
|
f.actionPurple_Flag.triggered.connect(lambda: self.onSetFlag(2))
|
|
f.actionGreen_Flag.triggered.connect(lambda: self.onSetFlag(3))
|
|
f.actionBlue_Flag.triggered.connect(lambda: self.onSetFlag(4))
|
|
f.actionClear_Flag.triggered.connect(lambda: self.onSetFlag(0))
|
|
# jumps
|
|
f.actionPreviousCard.triggered.connect(self.onPreviousCard)
|
|
f.actionNextCard.triggered.connect(self.onNextCard)
|
|
f.actionFirstCard.triggered.connect(self.onFirstCard)
|
|
f.actionLastCard.triggered.connect(self.onLastCard)
|
|
f.actionFind.triggered.connect(self.onFind)
|
|
f.actionNote.triggered.connect(self.onNote)
|
|
f.actionTags.triggered.connect(self.onFilterButton)
|
|
f.actionCardList.triggered.connect(self.onCardList)
|
|
# help
|
|
f.actionGuide.triggered.connect(self.onHelp)
|
|
# keyboard shortcut for shift+home/end
|
|
self.pgUpCut = QShortcut(QKeySequence("Shift+Home"), self)
|
|
self.pgUpCut.activated.connect(self.onFirstCard)
|
|
self.pgDownCut = QShortcut(QKeySequence("Shift+End"), self)
|
|
self.pgDownCut.activated.connect(self.onLastCard)
|
|
# add-on hook
|
|
runHook('browser.setupMenus', self)
|
|
self.mw.maybeHideAccelerators(self)
|
|
|
|
def updateFont(self):
|
|
# we can't choose different line heights efficiently, so we need
|
|
# to pick a line height big enough for any card template
|
|
curmax = 16
|
|
for m in self.col.models.all():
|
|
for t in m['tmpls']:
|
|
bsize = t.get("bsize", 0)
|
|
if bsize > curmax:
|
|
curmax = bsize
|
|
self.form.tableView.verticalHeader().setDefaultSectionSize(
|
|
curmax + 6)
|
|
|
|
def closeEvent(self, evt):
|
|
if not self._closeEventHasCleanedUp:
|
|
if self.editor.note and not self.forceClose:
|
|
# ignore event for now to allow us to save
|
|
self.editor.saveNow(self._closeEventAfterSave)
|
|
evt.ignore()
|
|
else:
|
|
self._closeEventCleanup()
|
|
evt.accept()
|
|
self.mw.gcWindow(self)
|
|
else:
|
|
evt.accept()
|
|
self.mw.gcWindow(self)
|
|
|
|
def _closeEventAfterSave(self):
|
|
self._closeEventCleanup()
|
|
self.close()
|
|
|
|
def _closeEventCleanup(self):
|
|
self._cancelPreviewTimer()
|
|
self.editor.setNote(None)
|
|
saveSplitter(self.form.splitter, "editor3")
|
|
saveGeom(self, "editor")
|
|
saveState(self, "editor")
|
|
saveHeader(self.form.tableView.horizontalHeader(), "editor")
|
|
self.col.conf['activeCols'] = self.model.activeCols
|
|
self.col.setMod()
|
|
self.teardownHooks()
|
|
self.mw.maybeReset()
|
|
aqt.dialogs.close("Browser")
|
|
self._closeEventHasCleanedUp = True
|
|
|
|
def canClose(self):
|
|
return True
|
|
|
|
def keyPressEvent(self, evt):
|
|
"Show answer on RET or register answer."
|
|
if evt.key() == Qt.Key_Escape:
|
|
self.close()
|
|
|
|
def setupColumns(self):
|
|
self.columns = [
|
|
('question', _("Question")),
|
|
('answer', _("Answer")),
|
|
('template', _("Card")),
|
|
('deck', _("Deck")),
|
|
('noteFld', _("Sort Field")),
|
|
('noteCrt', _("Created")),
|
|
('noteMod', _("Edited")),
|
|
('cardMod', _("Changed")),
|
|
('cardDue', _("Due")),
|
|
('cardIvl', _("Interval")),
|
|
('cardEase', _("Ease")),
|
|
('cardReps', _("Reviews")),
|
|
('cardLapses', _("Lapses")),
|
|
('noteTags', _("Tags")),
|
|
('note', _("Note")),
|
|
]
|
|
self.columns.sort(key=itemgetter(1))
|
|
|
|
# Searching
|
|
######################################################################
|
|
|
|
def setupSearch(self):
|
|
self.form.searchButton.clicked.connect(self.onSearchActivated)
|
|
self.form.searchEdit.lineEdit().returnPressed.connect(self.onSearchActivated)
|
|
self.form.searchEdit.setCompleter(None)
|
|
self._searchPrompt = _("<type here to search; hit enter to show current deck>")
|
|
self.form.searchEdit.addItems([self._searchPrompt] + self.mw.pm.profile['searchHistory'])
|
|
self._lastSearchTxt = "is:current"
|
|
self.search()
|
|
# then replace text for easily showing the deck
|
|
self.form.searchEdit.lineEdit().setText(self._searchPrompt)
|
|
self.form.searchEdit.lineEdit().selectAll()
|
|
self.form.searchEdit.setFocus()
|
|
|
|
# search triggered by user
|
|
def onSearchActivated(self):
|
|
self.editor.saveNow(self._onSearchActivated)
|
|
|
|
def _onSearchActivated(self):
|
|
# convert guide text before we save history
|
|
if self.form.searchEdit.lineEdit().text() == self._searchPrompt:
|
|
self.form.searchEdit.lineEdit().setText("deck:current ")
|
|
|
|
# update history
|
|
txt = str(self.form.searchEdit.lineEdit().text()).strip()
|
|
sh = self.mw.pm.profile['searchHistory']
|
|
if txt in sh:
|
|
sh.remove(txt)
|
|
sh.insert(0, txt)
|
|
sh = sh[:30]
|
|
self.form.searchEdit.clear()
|
|
self.form.searchEdit.addItems(sh)
|
|
self.mw.pm.profile['searchHistory'] = sh
|
|
|
|
# keep track of search string so that we reuse identical search when
|
|
# refreshing, rather than whatever is currently in the search field
|
|
self._lastSearchTxt = txt
|
|
self.search()
|
|
|
|
# search triggered programmatically. caller must have saved note first.
|
|
def search(self):
|
|
if "is:current" in self._lastSearchTxt:
|
|
# show current card if there is one
|
|
c = self.mw.reviewer.card
|
|
nid = c and c.nid or 0
|
|
self.model.search("nid:%d"%nid)
|
|
else:
|
|
self.model.search(self._lastSearchTxt)
|
|
|
|
if not self.model.cards:
|
|
# no row change will fire
|
|
self._onRowChanged(None, None)
|
|
|
|
def updateTitle(self):
|
|
selected = len(self.form.tableView.selectionModel().selectedRows())
|
|
cur = len(self.model.cards)
|
|
self.setWindowTitle(ngettext("Browse (%(cur)d card shown; %(sel)s)",
|
|
"Browse (%(cur)d cards shown; %(sel)s)",
|
|
cur) % {
|
|
"cur": cur,
|
|
"sel": ngettext("%d selected", "%d selected", selected) % selected
|
|
})
|
|
return selected
|
|
|
|
def onReset(self):
|
|
self.editor.setNote(None)
|
|
self.search()
|
|
|
|
# Table view & editor
|
|
######################################################################
|
|
|
|
def setupTable(self):
|
|
self.model = DataModel(self)
|
|
self.form.tableView.setSortingEnabled(True)
|
|
self.form.tableView.setModel(self.model)
|
|
self.form.tableView.selectionModel()
|
|
self.form.tableView.setItemDelegate(StatusDelegate(self, self.model))
|
|
self.form.tableView.selectionModel().selectionChanged.connect(self.onRowChanged)
|
|
|
|
def setupEditor(self):
|
|
self.editor = aqt.editor.Editor(
|
|
self.mw, self.form.fieldsArea, self)
|
|
|
|
def onRowChanged(self, current, previous):
|
|
"Update current note and hide/show editor."
|
|
self.editor.saveNow(lambda: self._onRowChanged(current, previous))
|
|
|
|
def _onRowChanged(self, current, previous):
|
|
update = self.updateTitle()
|
|
show = self.model.cards and update == 1
|
|
self.form.splitter.widget(1).setVisible(not not show)
|
|
if not show:
|
|
self.editor.setNote(None)
|
|
self.singleCard = False
|
|
else:
|
|
self.card = self.model.getCard(
|
|
self.form.tableView.selectionModel().currentIndex())
|
|
self.editor.setNote(self.card.note(reload=True), focusTo=self.focusTo)
|
|
self.focusTo = None
|
|
self.editor.card = self.card
|
|
self.singleCard = True
|
|
self._renderPreview(True)
|
|
|
|
def refreshCurrentCard(self, note):
|
|
self.model.refreshNote(note)
|
|
self._renderPreview(False)
|
|
|
|
def refreshCurrentCardFilter(self, flag, note, fidx):
|
|
self.refreshCurrentCard(note)
|
|
return flag
|
|
|
|
def currentRow(self):
|
|
idx = self.form.tableView.selectionModel().currentIndex()
|
|
return idx.row()
|
|
|
|
# Headers & sorting
|
|
######################################################################
|
|
|
|
def setupHeaders(self):
|
|
vh = self.form.tableView.verticalHeader()
|
|
hh = self.form.tableView.horizontalHeader()
|
|
if not isWin:
|
|
vh.hide()
|
|
hh.show()
|
|
restoreHeader(hh, "editor")
|
|
hh.setHighlightSections(False)
|
|
hh.setMinimumSectionSize(50)
|
|
hh.setSectionsMovable(True)
|
|
self.setColumnSizes()
|
|
hh.setContextMenuPolicy(Qt.CustomContextMenu)
|
|
hh.customContextMenuRequested.connect(self.onHeaderContext)
|
|
self.setSortIndicator()
|
|
hh.sortIndicatorChanged.connect(self.onSortChanged)
|
|
hh.sectionMoved.connect(self.onColumnMoved)
|
|
|
|
def onSortChanged(self, idx, ord):
|
|
self.editor.saveNow(lambda: self._onSortChanged(idx, ord))
|
|
|
|
def _onSortChanged(self, idx, ord):
|
|
type = self.model.activeCols[idx]
|
|
noSort = ("question", "answer", "template", "deck", "note", "noteTags")
|
|
if type in noSort:
|
|
if type == "template":
|
|
showInfo(_("""\
|
|
This column can't be sorted on, but you can search for individual card types, \
|
|
such as 'card:1'."""))
|
|
elif type == "deck":
|
|
showInfo(_("""\
|
|
This column can't be sorted on, but you can search for specific decks \
|
|
by clicking on one on the left."""))
|
|
else:
|
|
showInfo(_("Sorting on this column is not supported. Please "
|
|
"choose another."))
|
|
type = self.col.conf['sortType']
|
|
if self.col.conf['sortType'] != type:
|
|
self.col.conf['sortType'] = type
|
|
# default to descending for non-text fields
|
|
if type == "noteFld":
|
|
ord = not ord
|
|
self.col.conf['sortBackwards'] = ord
|
|
self.search()
|
|
else:
|
|
if self.col.conf['sortBackwards'] != ord:
|
|
self.col.conf['sortBackwards'] = ord
|
|
self.model.reverse()
|
|
self.setSortIndicator()
|
|
|
|
def setSortIndicator(self):
|
|
hh = self.form.tableView.horizontalHeader()
|
|
type = self.col.conf['sortType']
|
|
if type not in self.model.activeCols:
|
|
hh.setSortIndicatorShown(False)
|
|
return
|
|
idx = self.model.activeCols.index(type)
|
|
if self.col.conf['sortBackwards']:
|
|
ord = Qt.DescendingOrder
|
|
else:
|
|
ord = Qt.AscendingOrder
|
|
hh.blockSignals(True)
|
|
hh.setSortIndicator(idx, ord)
|
|
hh.blockSignals(False)
|
|
hh.setSortIndicatorShown(True)
|
|
|
|
def onHeaderContext(self, pos):
|
|
gpos = self.form.tableView.mapToGlobal(pos)
|
|
m = QMenu()
|
|
for type, name in self.columns:
|
|
a = m.addAction(name)
|
|
a.setCheckable(True)
|
|
a.setChecked(type in self.model.activeCols)
|
|
a.toggled.connect(lambda b, t=type: self.toggleField(t))
|
|
m.exec_(gpos)
|
|
|
|
def toggleField(self, type):
|
|
self.editor.saveNow(lambda: self._toggleField(type))
|
|
|
|
def _toggleField(self, type):
|
|
self.model.beginReset()
|
|
if type in self.model.activeCols:
|
|
if len(self.model.activeCols) < 2:
|
|
return showInfo(_("You must have at least one column."))
|
|
self.model.activeCols.remove(type)
|
|
adding=False
|
|
else:
|
|
self.model.activeCols.append(type)
|
|
adding=True
|
|
# sorted field may have been hidden
|
|
self.setSortIndicator()
|
|
self.setColumnSizes()
|
|
self.model.endReset()
|
|
# if we added a column, scroll to it
|
|
if adding:
|
|
row = self.currentRow()
|
|
idx = self.model.index(row, len(self.model.activeCols) - 1)
|
|
self.form.tableView.scrollTo(idx)
|
|
|
|
def setColumnSizes(self):
|
|
hh = self.form.tableView.horizontalHeader()
|
|
hh.setSectionResizeMode(QHeaderView.Interactive)
|
|
hh.setSectionResizeMode(hh.logicalIndex(len(self.model.activeCols)-1),
|
|
QHeaderView.Stretch)
|
|
# this must be set post-resize or it doesn't work
|
|
hh.setCascadingSectionResizes(False)
|
|
|
|
def onColumnMoved(self, a, b, c):
|
|
self.setColumnSizes()
|
|
|
|
# Filter tree
|
|
######################################################################
|
|
|
|
def onFilterButton(self):
|
|
m = QMenu()
|
|
|
|
self._addCommonFilters(m)
|
|
m.addSeparator()
|
|
|
|
self._addTodayFilters(m)
|
|
self._addCardStateFilters(m)
|
|
self._addDeckFilters(m)
|
|
self._addNoteTypeFilters(m)
|
|
self._addTagFilters(m)
|
|
|
|
self._addSavedSearches(m)
|
|
|
|
m.exec_(self.form.filter.mapToGlobal(QPoint(0,0)))
|
|
|
|
def setFilter(self, *args):
|
|
if len(args) == 1:
|
|
txt = args[0]
|
|
else:
|
|
txt = ""
|
|
items = []
|
|
for c, a in enumerate(args):
|
|
if c % 2 == 0:
|
|
txt += a + ":"
|
|
else:
|
|
txt += a
|
|
if " " in txt or "(" in txt or ")" in txt:
|
|
txt = '"%s"' % txt
|
|
items.append(txt)
|
|
txt = ""
|
|
txt = " ".join(items)
|
|
if self.mw.app.keyboardModifiers() & Qt.AltModifier:
|
|
txt = "-"+txt
|
|
if self.mw.app.keyboardModifiers() & Qt.ControlModifier:
|
|
cur = str(self.form.searchEdit.lineEdit().text())
|
|
if cur and cur != self._searchPrompt:
|
|
txt = cur + " " + txt
|
|
elif self.mw.app.keyboardModifiers() & Qt.ShiftModifier:
|
|
cur = str(self.form.searchEdit.lineEdit().text())
|
|
if cur:
|
|
txt = cur + " or " + txt
|
|
self.form.searchEdit.lineEdit().setText(txt)
|
|
self.onSearchActivated()
|
|
|
|
def _addSimpleFilters(self, m, items):
|
|
for row in items:
|
|
if row is None:
|
|
m.addSeparator()
|
|
else:
|
|
label, search = row
|
|
a = m.addAction(label)
|
|
a.triggered.connect(lambda *, f=search: self.setFilter(f))
|
|
|
|
def _addCommonFilters(self, m):
|
|
items = (
|
|
(_("Whole Collection"), ""),
|
|
(_("Current Deck"), "deck:current"))
|
|
self._addSimpleFilters(m, items)
|
|
|
|
def _addTodayFilters(self, m):
|
|
m = m.addMenu(_("Today"))
|
|
items = (
|
|
(_("Added Today"), "added:1"),
|
|
(_("Studied Today"), "rated:1"),
|
|
(_("Again Today"), "rated:1:1"))
|
|
self._addSimpleFilters(m, items)
|
|
|
|
def _addCardStateFilters(self, m):
|
|
m = m.addMenu(_("Card State"))
|
|
items = (
|
|
(_("New"), "is:new"),
|
|
(_("Learning"), "is:learn"),
|
|
(_("Review"), "is:review"),
|
|
(_("Due"), "is:due"),
|
|
None,
|
|
(_("Suspended"), "is:suspended"),
|
|
(_("Buried"), "is:buried"),
|
|
None,
|
|
(_("Red Flag"), "flag:1"),
|
|
(_("Purple Flag"), "flag:2"),
|
|
(_("Green Flag"), "flag:3"),
|
|
(_("Blue Flag"), "flag:4"),
|
|
(_("No Flag"), "flag:0"),
|
|
(_("Any Flag"), "-flag:0"),
|
|
)
|
|
self._addSimpleFilters(m, items)
|
|
|
|
_tagsMenuSize = 30
|
|
|
|
def _addTagFilters(self, m):
|
|
m = m.addMenu(_("Tags"))
|
|
|
|
a = m.addAction(_("Clear Unused"))
|
|
a.triggered.connect(self.clearUnusedTags)
|
|
m.addSeparator()
|
|
|
|
tags = sorted(self.col.tags.all(), key=lambda s: s.lower())
|
|
|
|
if len(tags) < self._tagsMenuSize:
|
|
self._addTagFilterBlock(m, tags)
|
|
else:
|
|
# split the list into a more manageable size
|
|
chunks = []
|
|
while tags:
|
|
chunk = tags[:self._tagsMenuSize]
|
|
chunks.append(chunk)
|
|
del tags[:self._tagsMenuSize]
|
|
# use separate menu for each chunk
|
|
for chunk in chunks:
|
|
name = chunk[0]+"..."
|
|
child = m.addMenu(name)
|
|
self._addTagFilterBlock(child, chunk)
|
|
|
|
def _addTagFilterBlock(self, m, tags):
|
|
for t in tags:
|
|
a = m.addAction(t)
|
|
a.triggered.connect(lambda *, tag=t: self.setFilter("tag", tag))
|
|
|
|
def _addDeckFilters(self, m):
|
|
def addDecks(parent, decks):
|
|
for head, did, rev, lrn, new, children in decks:
|
|
name = self.mw.col.decks.get(did)['name']
|
|
shortname = name.split("::")[-1]
|
|
if children:
|
|
newparent = parent.addMenu(shortname)
|
|
a = newparent.addAction(_("Filter"))
|
|
a.triggered.connect(
|
|
lambda *, name=name: self.setFilter("deck", name))
|
|
newparent.addSeparator()
|
|
addDecks(newparent, children)
|
|
else:
|
|
a = parent.addAction(shortname)
|
|
a.triggered.connect(
|
|
lambda *, name=name: self.setFilter("deck", name))
|
|
|
|
# fixme: could rewrite to avoid calculating due # in the future
|
|
alldecks = self.col.sched.deckDueTree()
|
|
root = m.addMenu(_("Decks"))
|
|
|
|
addDecks(root, alldecks)
|
|
|
|
def _addNoteTypeFilters(self, m):
|
|
m = m.addMenu(_("Note Types"))
|
|
a = m.addAction(_("Manage..."))
|
|
a.triggered.connect(self.mw.onNoteTypes)
|
|
m.addSeparator()
|
|
for nt in sorted(self.col.models.all(), key=itemgetter("name")):
|
|
# no sub menu if it's a single template
|
|
if len(nt['tmpls']) == 1:
|
|
a = m.addAction(nt['name'])
|
|
a.triggered.connect(lambda *, nt=nt: self.setFilter("mid", str(nt['id'])))
|
|
else:
|
|
subm = m.addMenu(nt['name'])
|
|
a = subm.addAction(_("All Card Types"))
|
|
a.triggered.connect(lambda *, nt=nt: self.setFilter("mid", str(nt['id'])))
|
|
|
|
# add templates
|
|
subm.addSeparator()
|
|
for c, tmpl in enumerate(nt['tmpls']):
|
|
a = subm.addAction(_("%(n)d: %(name)s") % dict(
|
|
n=c+1, name=tmpl['name']))
|
|
a.triggered.connect(lambda *, nt=nt, c=c: self.setFilter(
|
|
"mid", str(nt['id']), "card", str(c+1)
|
|
))
|
|
|
|
# Favourites
|
|
######################################################################
|
|
|
|
def _addSavedSearches(self, m):
|
|
# make sure exists
|
|
if "savedFilters" not in self.col.conf:
|
|
self.col.conf['savedFilters'] = {}
|
|
|
|
m.addSeparator()
|
|
|
|
if self._currentFilterIsSaved():
|
|
a = m.addAction(_("Remove Current Filter..."))
|
|
a.triggered.connect(self._onRemoveFilter)
|
|
else:
|
|
a = m.addAction(_("Save Current Filter..."))
|
|
a.triggered.connect(self._onSaveFilter)
|
|
|
|
saved = self.col.conf['savedFilters']
|
|
if not saved:
|
|
return
|
|
|
|
m.addSeparator()
|
|
for name, filt in sorted(saved.items()):
|
|
a = m.addAction(name)
|
|
a.triggered.connect(lambda *, f=filt: self.setFilter(f))
|
|
|
|
def _onSaveFilter(self):
|
|
name = getOnlyText(_("Please give your filter a name:"))
|
|
if not name:
|
|
return
|
|
filt = self.form.searchEdit.lineEdit().text()
|
|
self.col.conf['savedFilters'][name] = filt
|
|
self.col.setMod()
|
|
|
|
def _onRemoveFilter(self):
|
|
name = self._currentFilterIsSaved()
|
|
if not askUser(_("Remove %s from your saved searches?") % name):
|
|
return
|
|
del self.col.conf['savedFilters'][name]
|
|
self.col.setMod()
|
|
|
|
# returns name if found
|
|
def _currentFilterIsSaved(self):
|
|
filt = self.form.searchEdit.lineEdit().text()
|
|
for k,v in self.col.conf['savedFilters'].items():
|
|
if filt == v:
|
|
return k
|
|
return None
|
|
|
|
# Info
|
|
######################################################################
|
|
|
|
def showCardInfo(self):
|
|
if not self.card:
|
|
return
|
|
info, cs = self._cardInfoData()
|
|
reps = self._revlogData(cs)
|
|
d = QDialog(self)
|
|
l = QVBoxLayout()
|
|
l.setContentsMargins(0,0,0,0)
|
|
w = AnkiWebView()
|
|
l.addWidget(w)
|
|
w.stdHtml(info + "<p>" + reps)
|
|
bb = QDialogButtonBox(QDialogButtonBox.Close)
|
|
l.addWidget(bb)
|
|
bb.rejected.connect(d.reject)
|
|
d.setLayout(l)
|
|
d.setWindowModality(Qt.WindowModal)
|
|
d.resize(500, 400)
|
|
restoreGeom(d, "revlog")
|
|
d.show()
|
|
saveGeom(d, "revlog")
|
|
|
|
def _cardInfoData(self):
|
|
from anki.stats import CardStats
|
|
cs = CardStats(self.col, self.card)
|
|
rep = cs.report()
|
|
m = self.card.model()
|
|
rep = """
|
|
<div style='width: 400px; margin: 0 auto 0;
|
|
border: 1px solid #000; padding: 3px; '>%s</div>""" % rep
|
|
return rep, cs
|
|
|
|
def _revlogData(self, cs):
|
|
entries = self.mw.col.db.all(
|
|
"select id/1000.0, ease, ivl, factor, time/1000.0, type "
|
|
"from revlog where cid = ?", self.card.id)
|
|
if not entries:
|
|
return ""
|
|
s = "<table width=100%%><tr><th align=left>%s</th>" % _("Date")
|
|
s += ("<th align=right>%s</th>" * 5) % (
|
|
_("Type"), _("Rating"), _("Interval"), _("Ease"), _("Time"))
|
|
cnt = 0
|
|
for (date, ease, ivl, factor, taken, type) in reversed(entries):
|
|
cnt += 1
|
|
s += "<tr><td>%s</td>" % time.strftime(_("<b>%Y-%m-%d</b> @ %H:%M"),
|
|
time.localtime(date))
|
|
tstr = [_("Learn"), _("Review"), _("Relearn"), _("Filtered"),
|
|
_("Resched")][type]
|
|
import anki.stats as st
|
|
fmt = "<span style='color:%s'>%s</span>"
|
|
if type == 0:
|
|
tstr = fmt % (st.colLearn, tstr)
|
|
elif type == 1:
|
|
tstr = fmt % (st.colMature, tstr)
|
|
elif type == 2:
|
|
tstr = fmt % (st.colRelearn, tstr)
|
|
elif type == 3:
|
|
tstr = fmt % (st.colCram, tstr)
|
|
else:
|
|
tstr = fmt % ("#000", tstr)
|
|
if ease == 1:
|
|
ease = fmt % (st.colRelearn, ease)
|
|
if ivl == 0:
|
|
ivl = _("0d")
|
|
elif ivl > 0:
|
|
ivl = fmtTimeSpan(ivl*86400, short=True)
|
|
else:
|
|
ivl = cs.time(-ivl)
|
|
s += ("<td align=right>%s</td>" * 5) % (
|
|
tstr,
|
|
ease, ivl,
|
|
"%d%%" % (factor/10) if factor else "",
|
|
cs.time(taken)) + "</tr>"
|
|
s += "</table>"
|
|
if cnt < self.card.reps:
|
|
s += _("""\
|
|
Note: Some of the history is missing. For more information, \
|
|
please see the browser documentation.""")
|
|
return s
|
|
|
|
# Menu helpers
|
|
######################################################################
|
|
|
|
def selectedCards(self):
|
|
return [self.model.cards[idx.row()] for idx in
|
|
self.form.tableView.selectionModel().selectedRows()]
|
|
|
|
def selectedNotes(self):
|
|
return self.col.db.list("""
|
|
select distinct nid from cards
|
|
where id in %s""" % ids2str(
|
|
[self.model.cards[idx.row()] for idx in
|
|
self.form.tableView.selectionModel().selectedRows()]))
|
|
|
|
def selectedNotesAsCards(self):
|
|
return self.col.db.list(
|
|
"select id from cards where nid in (%s)" %
|
|
",".join([str(s) for s in self.selectedNotes()]))
|
|
|
|
def oneModelNotes(self):
|
|
sf = self.selectedNotes()
|
|
if not sf:
|
|
return
|
|
mods = self.col.db.scalar("""
|
|
select count(distinct mid) from notes
|
|
where id in %s""" % ids2str(sf))
|
|
if mods > 1:
|
|
showInfo(_("Please select cards from only one note type."))
|
|
return
|
|
return sf
|
|
|
|
def onHelp(self):
|
|
openHelp("browser")
|
|
|
|
# Misc menu options
|
|
######################################################################
|
|
|
|
def onChangeModel(self):
|
|
self.editor.saveNow(self._onChangeModel)
|
|
|
|
def _onChangeModel(self):
|
|
nids = self.oneModelNotes()
|
|
if nids:
|
|
ChangeModel(self, nids)
|
|
|
|
# Preview
|
|
######################################################################
|
|
|
|
_previewTimer = None
|
|
_lastPreviewRender = 0
|
|
|
|
def onTogglePreview(self):
|
|
if self._previewWindow:
|
|
self._closePreview()
|
|
else:
|
|
self._openPreview()
|
|
|
|
def _openPreview(self):
|
|
self._previewState = "question"
|
|
self._previewWindow = QDialog(None, Qt.Window)
|
|
self._previewWindow.setWindowTitle(_("Preview"))
|
|
|
|
self._previewWindow.finished.connect(self._onPreviewFinished)
|
|
vbox = QVBoxLayout()
|
|
vbox.setContentsMargins(0,0,0,0)
|
|
self._previewWeb = AnkiWebView()
|
|
vbox.addWidget(self._previewWeb)
|
|
bbox = QDialogButtonBox()
|
|
|
|
self._previewReplay = bbox.addButton(_("Replay Audio"), QDialogButtonBox.ActionRole)
|
|
self._previewReplay.setAutoDefault(False)
|
|
self._previewReplay.setShortcut(QKeySequence("R"))
|
|
self._previewReplay.setToolTip(_("Shortcut key: %s" % "R"))
|
|
|
|
self._previewPrev = bbox.addButton("<", QDialogButtonBox.ActionRole)
|
|
self._previewPrev.setAutoDefault(False)
|
|
self._previewPrev.setShortcut(QKeySequence("Left"))
|
|
self._previewPrev.setToolTip(_("Shortcut key: Left arrow"))
|
|
|
|
self._previewNext = bbox.addButton(">", QDialogButtonBox.ActionRole)
|
|
self._previewNext.setAutoDefault(True)
|
|
self._previewNext.setShortcut(QKeySequence("Right"))
|
|
self._previewNext.setToolTip(_("Shortcut key: Right arrow or Enter"))
|
|
|
|
self._previewPrev.clicked.connect(self._onPreviewPrev)
|
|
self._previewNext.clicked.connect(self._onPreviewNext)
|
|
self._previewReplay.clicked.connect(self._onReplayAudio)
|
|
|
|
self._setupPreviewWebview()
|
|
|
|
vbox.addWidget(bbox)
|
|
self._previewWindow.setLayout(vbox)
|
|
restoreGeom(self._previewWindow, "preview")
|
|
self._previewWindow.show()
|
|
self._renderPreview(True)
|
|
|
|
def _onPreviewFinished(self, ok):
|
|
saveGeom(self._previewWindow, "preview")
|
|
self.mw.progress.timer(100, self._onClosePreview, False)
|
|
self.form.previewButton.setChecked(False)
|
|
|
|
def _onPreviewPrev(self):
|
|
if self._previewState == "answer":
|
|
self._previewState = "question"
|
|
self._renderPreview()
|
|
else:
|
|
self.editor.saveNow(lambda: self._moveCur(QAbstractItemView.MoveUp))
|
|
self._updatePreviewButtons()
|
|
|
|
def _onPreviewNext(self):
|
|
if self._previewState == "question":
|
|
self._previewState = "answer"
|
|
self._renderPreview()
|
|
else:
|
|
self.editor.saveNow(lambda: self._moveCur(QAbstractItemView.MoveDown))
|
|
self._updatePreviewButtons()
|
|
|
|
def _onReplayAudio(self):
|
|
self.mw.reviewer.replayAudio(self)
|
|
|
|
def _updatePreviewButtons(self):
|
|
if not self._previewWindow:
|
|
return
|
|
current = self.currentRow()
|
|
canBack = (current > 0 or (current == 0 and self._previewState == "answer" ))
|
|
self._previewPrev.setEnabled(not not (self.singleCard and canBack))
|
|
canForward = self.currentRow() < self.model.rowCount(None) - 1 or \
|
|
self._previewState == "question"
|
|
self._previewNext.setEnabled(not not (self.singleCard and canForward))
|
|
|
|
def _closePreview(self):
|
|
if self._previewWindow:
|
|
self._previewWindow.close()
|
|
self._onClosePreview()
|
|
|
|
def _onClosePreview(self):
|
|
self._previewWindow = self._previewPrev = self._previewNext = None
|
|
|
|
def _setupPreviewWebview(self):
|
|
jsinc = ["jquery.js","browsersel.js",
|
|
"mathjax/conf.js", "mathjax/MathJax.js",
|
|
"reviewer.js"]
|
|
self._previewWeb.stdHtml(self.mw.reviewer.revHtml(),
|
|
css=["reviewer.css"],
|
|
js=jsinc)
|
|
|
|
|
|
def _renderPreview(self, cardChanged=False):
|
|
self._cancelPreviewTimer()
|
|
# avoid rendering in quick succession
|
|
elapMS = int((time.time() - self._lastPreviewRender)*1000)
|
|
if elapMS < 500:
|
|
self._previewTimer = self.mw.progress.timer(
|
|
500-elapMS, lambda: self._renderScheduledPreview(cardChanged), False)
|
|
else:
|
|
self._renderScheduledPreview(cardChanged)
|
|
|
|
def _cancelPreviewTimer(self):
|
|
if self._previewTimer:
|
|
self._previewTimer.stop()
|
|
self._previewTimer = None
|
|
|
|
def _renderScheduledPreview(self, cardChanged=False):
|
|
self._cancelPreviewTimer()
|
|
self._lastPreviewRender = time.time()
|
|
|
|
if not self._previewWindow:
|
|
return
|
|
c = self.card
|
|
self._updatePreviewButtons()
|
|
func = "_showQuestion"
|
|
if not c or not self.singleCard:
|
|
txt = _("(please select 1 card)")
|
|
bodyclass = ""
|
|
else:
|
|
if cardChanged:
|
|
self._previewState = "question"
|
|
# need to force reload even if answer
|
|
txt = c.q(reload=True)
|
|
if self._previewState == "answer":
|
|
func = "_showAnswer"
|
|
txt = c.a()
|
|
txt = re.sub("\[\[type:[^]]+\]\]", "", txt)
|
|
|
|
bodyclass="card card%d" % (c.ord+1)
|
|
|
|
clearAudioQueue()
|
|
if self.mw.reviewer.autoplay(c):
|
|
playFromText(txt)
|
|
|
|
txt = mungeQA(self.col, txt)
|
|
|
|
self._previewWeb.eval(
|
|
f"{func}({json.dumps(txt)},'{bodyclass}');")
|
|
|
|
# Card deletion
|
|
######################################################################
|
|
|
|
def deleteNotes(self):
|
|
self.editor.saveNow(self._deleteNotes)
|
|
|
|
def _deleteNotes(self):
|
|
nids = self.selectedNotes()
|
|
if not nids:
|
|
return
|
|
self.mw.checkpoint(_("Delete Notes"))
|
|
self.model.beginReset()
|
|
# figure out where to place the cursor after the deletion
|
|
curRow = self.form.tableView.selectionModel().currentIndex().row()
|
|
selectedRows = [i.row() for i in
|
|
self.form.tableView.selectionModel().selectedRows()]
|
|
if min(selectedRows) < curRow < max(selectedRows):
|
|
# last selection in middle; place one below last selected item
|
|
move = sum(1 for i in selectedRows if i > curRow)
|
|
newRow = curRow - move
|
|
elif max(selectedRows) <= curRow:
|
|
# last selection at bottom; place one below bottommost selection
|
|
newRow = max(selectedRows) - len(nids) + 1
|
|
else:
|
|
# last selection at top; place one above topmost selection
|
|
newRow = min(selectedRows) - 1
|
|
self.col.remNotes(nids)
|
|
self.search()
|
|
if len(self.model.cards):
|
|
newRow = min(newRow, len(self.model.cards) - 1)
|
|
newRow = max(newRow, 0)
|
|
self.model.focusedCard = self.model.cards[newRow]
|
|
self.model.endReset()
|
|
self.mw.requireReset()
|
|
tooltip(ngettext("%d note deleted.", "%d notes deleted.", len(nids)) % len(nids))
|
|
|
|
# Deck change
|
|
######################################################################
|
|
|
|
def setDeck(self):
|
|
self.editor.saveNow(self._setDeck)
|
|
|
|
def _setDeck(self):
|
|
from aqt.studydeck import StudyDeck
|
|
cids = self.selectedCards()
|
|
if not cids:
|
|
return
|
|
did = self.mw.col.db.scalar(
|
|
"select did from cards where id = ?", cids[0])
|
|
current=self.mw.col.decks.get(did)['name']
|
|
ret = StudyDeck(
|
|
self.mw, current=current, accept=_("Move Cards"),
|
|
title=_("Change Deck"), help="browse", parent=self)
|
|
if not ret.name:
|
|
return
|
|
did = self.col.decks.id(ret.name)
|
|
deck = self.col.decks.get(did)
|
|
if deck['dyn']:
|
|
showWarning(_("Cards can't be manually moved into a filtered deck."))
|
|
return
|
|
self.model.beginReset()
|
|
self.mw.checkpoint(_("Change Deck"))
|
|
mod = intTime()
|
|
usn = self.col.usn()
|
|
# normal cards
|
|
scids = ids2str(cids)
|
|
# remove any cards from filtered deck first
|
|
self.col.sched.remFromDyn(cids)
|
|
# then move into new deck
|
|
self.col.db.execute("""
|
|
update cards set usn=?, mod=?, did=? where id in """ + scids,
|
|
usn, mod, did)
|
|
self.model.endReset()
|
|
self.mw.requireReset()
|
|
|
|
# Tags
|
|
######################################################################
|
|
|
|
def addTags(self, tags=None, label=None, prompt=None, func=None):
|
|
self.editor.saveNow(lambda: self._addTags(tags, label, prompt, func))
|
|
|
|
def _addTags(self, tags, label, prompt, func):
|
|
if prompt is None:
|
|
prompt = _("Enter tags to add:")
|
|
if tags is None:
|
|
(tags, r) = getTag(self, self.col, prompt)
|
|
else:
|
|
r = True
|
|
if not r:
|
|
return
|
|
if func is None:
|
|
func = self.col.tags.bulkAdd
|
|
if label is None:
|
|
label = _("Add Tags")
|
|
if label:
|
|
self.mw.checkpoint(label)
|
|
self.model.beginReset()
|
|
func(self.selectedNotes(), tags)
|
|
self.model.endReset()
|
|
self.mw.requireReset()
|
|
|
|
def deleteTags(self, tags=None, label=None):
|
|
if label is None:
|
|
label = _("Delete Tags")
|
|
self.addTags(tags, label, _("Enter tags to delete:"),
|
|
func=self.col.tags.bulkRem)
|
|
|
|
def clearUnusedTags(self):
|
|
self.editor.saveNow(self._clearUnusedTags)
|
|
|
|
def _clearUnusedTags(self):
|
|
self.col.tags.registerNotes()
|
|
|
|
# Suspending
|
|
######################################################################
|
|
|
|
def isSuspended(self):
|
|
return not not (self.card and self.card.queue == -1)
|
|
|
|
def onSuspend(self):
|
|
self.editor.saveNow(self._onSuspend)
|
|
|
|
def _onSuspend(self):
|
|
sus = not self.isSuspended()
|
|
c = self.selectedCards()
|
|
if sus:
|
|
self.col.sched.suspendCards(c)
|
|
else:
|
|
self.col.sched.unsuspendCards(c)
|
|
self.model.reset()
|
|
self.mw.requireReset()
|
|
|
|
# Flags
|
|
######################################################################
|
|
|
|
def onSetFlag(self, n):
|
|
self.col.setUserFlag(n, self.selectedCards())
|
|
self.model.reset()
|
|
|
|
# Repositioning
|
|
######################################################################
|
|
|
|
def reposition(self):
|
|
self.editor.saveNow(self._reposition)
|
|
|
|
def _reposition(self):
|
|
cids = self.selectedCards()
|
|
cids2 = self.col.db.list(
|
|
"select id from cards where type = 0 and id in " + ids2str(cids))
|
|
if not cids2:
|
|
return showInfo(_("Only new cards can be repositioned."))
|
|
d = QDialog(self)
|
|
d.setWindowModality(Qt.WindowModal)
|
|
frm = aqt.forms.reposition.Ui_Dialog()
|
|
frm.setupUi(d)
|
|
(pmin, pmax) = self.col.db.first(
|
|
"select min(due), max(due) from cards where type=0 and odid=0")
|
|
pmin = pmin or 0
|
|
pmax = pmax or 0
|
|
txt = _("Queue top: %d") % pmin
|
|
txt += "\n" + _("Queue bottom: %d") % pmax
|
|
frm.label.setText(txt)
|
|
if not d.exec_():
|
|
return
|
|
self.model.beginReset()
|
|
self.mw.checkpoint(_("Reposition"))
|
|
self.col.sched.sortCards(
|
|
cids, start=frm.start.value(), step=frm.step.value(),
|
|
shuffle=frm.randomize.isChecked(), shift=frm.shift.isChecked())
|
|
self.search()
|
|
self.mw.requireReset()
|
|
self.model.endReset()
|
|
|
|
# Rescheduling
|
|
######################################################################
|
|
|
|
def reschedule(self):
|
|
self.editor.saveNow(self._reschedule)
|
|
|
|
def _reschedule(self):
|
|
d = QDialog(self)
|
|
d.setWindowModality(Qt.WindowModal)
|
|
frm = aqt.forms.reschedule.Ui_Dialog()
|
|
frm.setupUi(d)
|
|
if not d.exec_():
|
|
return
|
|
self.model.beginReset()
|
|
self.mw.checkpoint(_("Reschedule"))
|
|
if frm.asNew.isChecked():
|
|
self.col.sched.forgetCards(self.selectedCards())
|
|
else:
|
|
fmin = frm.min.value()
|
|
fmax = frm.max.value()
|
|
fmax = max(fmin, fmax)
|
|
self.col.sched.reschedCards(
|
|
self.selectedCards(), fmin, fmax)
|
|
self.search()
|
|
self.mw.requireReset()
|
|
self.model.endReset()
|
|
|
|
# Edit: selection
|
|
######################################################################
|
|
|
|
def selectNotes(self):
|
|
self.editor.saveNow(self._selectNotes)
|
|
|
|
def _selectNotes(self):
|
|
nids = self.selectedNotes()
|
|
# bypass search history
|
|
self._lastSearchTxt = "nid:"+",".join([str(x) for x in nids])
|
|
self.form.searchEdit.lineEdit().setText(self._lastSearchTxt)
|
|
# clear the selection so we don't waste energy preserving it
|
|
tv = self.form.tableView
|
|
tv.selectionModel().clear()
|
|
self.search()
|
|
tv.selectAll()
|
|
|
|
def invertSelection(self):
|
|
sm = self.form.tableView.selectionModel()
|
|
items = sm.selection()
|
|
self.form.tableView.selectAll()
|
|
sm.select(items, QItemSelectionModel.Deselect | QItemSelectionModel.Rows)
|
|
|
|
# Edit: undo
|
|
######################################################################
|
|
|
|
def setupHooks(self):
|
|
addHook("undoState", self.onUndoState)
|
|
addHook("reset", self.onReset)
|
|
addHook("editTimer", self.refreshCurrentCard)
|
|
addHook("editFocusLost", self.refreshCurrentCardFilter)
|
|
|
|
def teardownHooks(self):
|
|
remHook("reset", self.onReset)
|
|
remHook("editTimer", self.refreshCurrentCard)
|
|
remHook("editFocusLost", self.refreshCurrentCardFilter)
|
|
remHook("undoState", self.onUndoState)
|
|
|
|
def onUndoState(self, on):
|
|
self.form.actionUndo.setEnabled(on)
|
|
if on:
|
|
self.form.actionUndo.setText(self.mw.form.actionUndo.text())
|
|
|
|
# Edit: replacing
|
|
######################################################################
|
|
|
|
def onFindReplace(self):
|
|
self.editor.saveNow(self._onFindReplace)
|
|
|
|
def _onFindReplace(self):
|
|
sf = self.selectedNotes()
|
|
if not sf:
|
|
return
|
|
import anki.find
|
|
fields = sorted(anki.find.fieldNames(self.col, downcase=False))
|
|
d = QDialog(self)
|
|
frm = aqt.forms.findreplace.Ui_Dialog()
|
|
frm.setupUi(d)
|
|
d.setWindowModality(Qt.WindowModal)
|
|
frm.field.addItems([_("All Fields")] + fields)
|
|
frm.buttonBox.helpRequested.connect(self.onFindReplaceHelp)
|
|
restoreGeom(d, "findreplace")
|
|
r = d.exec_()
|
|
saveGeom(d, "findreplace")
|
|
if not r:
|
|
return
|
|
if frm.field.currentIndex() == 0:
|
|
field = None
|
|
else:
|
|
field = fields[frm.field.currentIndex()-1]
|
|
self.mw.checkpoint(_("Find and Replace"))
|
|
self.mw.progress.start()
|
|
self.model.beginReset()
|
|
try:
|
|
changed = self.col.findReplace(sf,
|
|
str(frm.find.text()),
|
|
str(frm.replace.text()),
|
|
frm.re.isChecked(),
|
|
field,
|
|
frm.ignoreCase.isChecked())
|
|
except sre_constants.error:
|
|
showInfo(_("Invalid regular expression."), parent=self)
|
|
return
|
|
else:
|
|
self.search()
|
|
self.mw.requireReset()
|
|
finally:
|
|
self.model.endReset()
|
|
self.mw.progress.finish()
|
|
showInfo(ngettext(
|
|
"%(a)d of %(b)d note updated",
|
|
"%(a)d of %(b)d notes updated", len(sf)) % {
|
|
'a': changed,
|
|
'b': len(sf),
|
|
})
|
|
|
|
def onFindReplaceHelp(self):
|
|
openHelp("findreplace")
|
|
|
|
# Edit: finding dupes
|
|
######################################################################
|
|
|
|
def onFindDupes(self):
|
|
self.editor.saveNow(self._onFindDupes)
|
|
|
|
def _onFindDupes(self):
|
|
d = QDialog(self)
|
|
self.mw.setupDialogGC(d)
|
|
frm = aqt.forms.finddupes.Ui_Dialog()
|
|
frm.setupUi(d)
|
|
restoreGeom(d, "findDupes")
|
|
fields = sorted(anki.find.fieldNames(self.col, downcase=False))
|
|
frm.fields.addItems(fields)
|
|
self._dupesButton = None
|
|
# links
|
|
frm.webView.onBridgeCmd = self.dupeLinkClicked
|
|
def onFin(code):
|
|
saveGeom(d, "findDupes")
|
|
d.finished.connect(onFin)
|
|
def onClick():
|
|
field = fields[frm.fields.currentIndex()]
|
|
self.duplicatesReport(frm.webView, field, frm.search.text(), frm)
|
|
search = frm.buttonBox.addButton(
|
|
_("Search"), QDialogButtonBox.ActionRole)
|
|
search.clicked.connect(onClick)
|
|
d.show()
|
|
|
|
def duplicatesReport(self, web, fname, search, frm):
|
|
self.mw.progress.start()
|
|
res = self.mw.col.findDupes(fname, search)
|
|
if not self._dupesButton:
|
|
self._dupesButton = b = frm.buttonBox.addButton(
|
|
_("Tag Duplicates"), QDialogButtonBox.ActionRole)
|
|
b.clicked.connect(lambda: self._onTagDupes(res))
|
|
t = "<html><body>"
|
|
groups = len(res)
|
|
notes = sum(len(r[1]) for r in res)
|
|
part1 = ngettext("%d group", "%d groups", groups) % groups
|
|
part2 = ngettext("%d note", "%d notes", notes) % notes
|
|
t += _("Found %(a)s across %(b)s.") % dict(a=part1, b=part2)
|
|
t += "<p><ol>"
|
|
for val, nids in res:
|
|
t += '''<li><a href=# onclick="pycmd('%s')">%s</a>: %s</a>''' % (
|
|
"nid:" + ",".join(str(id) for id in nids),
|
|
ngettext("%d note", "%d notes", len(nids)) % len(nids),
|
|
cgi.escape(val))
|
|
t += "</ol>"
|
|
t += "</body></html>"
|
|
web.setHtml(t)
|
|
self.mw.progress.finish()
|
|
|
|
def _onTagDupes(self, res):
|
|
if not res:
|
|
return
|
|
self.model.beginReset()
|
|
self.mw.checkpoint(_("Tag Duplicates"))
|
|
nids = set()
|
|
for s, nidlist in res:
|
|
nids.update(nidlist)
|
|
self.col.tags.bulkAdd(nids, _("duplicate"))
|
|
self.mw.progress.finish()
|
|
self.model.endReset()
|
|
self.mw.requireReset()
|
|
tooltip(_("Notes tagged."))
|
|
|
|
def dupeLinkClicked(self, link):
|
|
self.form.searchEdit.lineEdit().setText(link)
|
|
# manually, because we've already saved
|
|
self._lastSearchTxt = link
|
|
self.search()
|
|
self.onNote()
|
|
|
|
# Jumping
|
|
######################################################################
|
|
|
|
def _moveCur(self, dir=None, idx=None):
|
|
if not self.model.cards:
|
|
return
|
|
tv = self.form.tableView
|
|
if idx is None:
|
|
idx = tv.moveCursor(dir, self.mw.app.keyboardModifiers())
|
|
tv.selectionModel().setCurrentIndex(
|
|
idx,
|
|
QItemSelectionModel.Clear|
|
|
QItemSelectionModel.Select|
|
|
QItemSelectionModel.Rows)
|
|
|
|
def onPreviousCard(self):
|
|
self.focusTo = self.editor.currentField
|
|
self.editor.saveNow(self._onPreviousCard)
|
|
|
|
def _onPreviousCard(self):
|
|
self._moveCur(QAbstractItemView.MoveUp)
|
|
|
|
def onNextCard(self):
|
|
self.focusTo = self.editor.currentField
|
|
self.editor.saveNow(self._onNextCard)
|
|
|
|
def _onNextCard(self):
|
|
self._moveCur(QAbstractItemView.MoveDown)
|
|
|
|
def onFirstCard(self):
|
|
sm = self.form.tableView.selectionModel()
|
|
idx = sm.currentIndex()
|
|
self._moveCur(None, self.model.index(0, 0))
|
|
if not self.mw.app.keyboardModifiers() & Qt.ShiftModifier:
|
|
return
|
|
idx2 = sm.currentIndex()
|
|
item = QItemSelection(idx2, idx)
|
|
sm.select(item, QItemSelectionModel.SelectCurrent|
|
|
QItemSelectionModel.Rows)
|
|
|
|
def onLastCard(self):
|
|
sm = self.form.tableView.selectionModel()
|
|
idx = sm.currentIndex()
|
|
self._moveCur(
|
|
None, self.model.index(len(self.model.cards) - 1, 0))
|
|
if not self.mw.app.keyboardModifiers() & Qt.ShiftModifier:
|
|
return
|
|
idx2 = sm.currentIndex()
|
|
item = QItemSelection(idx, idx2)
|
|
sm.select(item, QItemSelectionModel.SelectCurrent|
|
|
QItemSelectionModel.Rows)
|
|
|
|
def onFind(self):
|
|
self.form.searchEdit.setFocus()
|
|
self.form.searchEdit.lineEdit().selectAll()
|
|
|
|
def onNote(self):
|
|
self.editor.web.setFocus()
|
|
self.editor.web.eval("focusField(0);")
|
|
|
|
def onCardList(self):
|
|
self.form.tableView.setFocus()
|
|
|
|
def focusCid(self, cid):
|
|
try:
|
|
row = self.model.cards.index(cid)
|
|
except:
|
|
return
|
|
self.form.tableView.selectRow(row)
|
|
|
|
# Change model dialog
|
|
######################################################################
|
|
|
|
class ChangeModel(QDialog):
|
|
|
|
def __init__(self, browser, nids):
|
|
QDialog.__init__(self, browser)
|
|
self.browser = browser
|
|
self.nids = nids
|
|
self.oldModel = browser.card.note().model()
|
|
self.form = aqt.forms.changemodel.Ui_Dialog()
|
|
self.form.setupUi(self)
|
|
self.setWindowModality(Qt.WindowModal)
|
|
self.setup()
|
|
restoreGeom(self, "changeModel")
|
|
addHook("reset", self.onReset)
|
|
addHook("currentModelChanged", self.onReset)
|
|
self.exec_()
|
|
|
|
def setup(self):
|
|
# maps
|
|
self.flayout = QHBoxLayout()
|
|
self.flayout.setContentsMargins(0,0,0,0)
|
|
self.fwidg = None
|
|
self.form.fieldMap.setLayout(self.flayout)
|
|
self.tlayout = QHBoxLayout()
|
|
self.tlayout.setContentsMargins(0,0,0,0)
|
|
self.twidg = None
|
|
self.form.templateMap.setLayout(self.tlayout)
|
|
if self.style().objectName() == "gtk+":
|
|
# gtk+ requires margins in inner layout
|
|
self.form.verticalLayout_2.setContentsMargins(0, 11, 0, 0)
|
|
self.form.verticalLayout_3.setContentsMargins(0, 11, 0, 0)
|
|
# model chooser
|
|
import aqt.modelchooser
|
|
self.oldModel = self.browser.col.models.get(
|
|
self.browser.col.db.scalar(
|
|
"select mid from notes where id = ?", self.nids[0]))
|
|
self.form.oldModelLabel.setText(self.oldModel['name'])
|
|
self.modelChooser = aqt.modelchooser.ModelChooser(
|
|
self.browser.mw, self.form.modelChooserWidget, label=False)
|
|
self.modelChooser.models.setFocus()
|
|
self.form.buttonBox.helpRequested.connect(self.onHelp)
|
|
self.modelChanged(self.browser.mw.col.models.current())
|
|
self.pauseUpdate = False
|
|
|
|
def onReset(self):
|
|
self.modelChanged(self.browser.col.models.current())
|
|
|
|
def modelChanged(self, model):
|
|
self.targetModel = model
|
|
self.rebuildTemplateMap()
|
|
self.rebuildFieldMap()
|
|
|
|
def rebuildTemplateMap(self, key=None, attr=None):
|
|
if not key:
|
|
key = "t"
|
|
attr = "tmpls"
|
|
map = getattr(self, key + "widg")
|
|
lay = getattr(self, key + "layout")
|
|
src = self.oldModel[attr]
|
|
dst = self.targetModel[attr]
|
|
if map:
|
|
lay.removeWidget(map)
|
|
map.deleteLater()
|
|
setattr(self, key + "MapWidget", None)
|
|
map = QWidget()
|
|
l = QGridLayout()
|
|
combos = []
|
|
targets = [x['name'] for x in dst] + [_("Nothing")]
|
|
indices = {}
|
|
for i, x in enumerate(src):
|
|
l.addWidget(QLabel(_("Change %s to:") % x['name']), i, 0)
|
|
cb = QComboBox()
|
|
cb.addItems(targets)
|
|
idx = min(i, len(targets)-1)
|
|
cb.setCurrentIndex(idx)
|
|
indices[cb] = idx
|
|
cb.currentIndexChanged.connect(
|
|
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key))
|
|
combos.append(cb)
|
|
l.addWidget(cb, i, 1)
|
|
map.setLayout(l)
|
|
lay.addWidget(map)
|
|
setattr(self, key + "widg", map)
|
|
setattr(self, key + "layout", lay)
|
|
setattr(self, key + "combos", combos)
|
|
setattr(self, key + "indices", indices)
|
|
|
|
def rebuildFieldMap(self):
|
|
return self.rebuildTemplateMap(key="f", attr="flds")
|
|
|
|
def onComboChanged(self, i, cb, key):
|
|
indices = getattr(self, key + "indices")
|
|
if self.pauseUpdate:
|
|
indices[cb] = i
|
|
return
|
|
combos = getattr(self, key + "combos")
|
|
if i == cb.count() - 1:
|
|
# set to 'nothing'
|
|
return
|
|
# find another combo with same index
|
|
for c in combos:
|
|
if c == cb:
|
|
continue
|
|
if c.currentIndex() == i:
|
|
self.pauseUpdate = True
|
|
c.setCurrentIndex(indices[cb])
|
|
self.pauseUpdate = False
|
|
break
|
|
indices[cb] = i
|
|
|
|
def getTemplateMap(self, old=None, combos=None, new=None):
|
|
if not old:
|
|
old = self.oldModel['tmpls']
|
|
combos = self.tcombos
|
|
new = self.targetModel['tmpls']
|
|
map = {}
|
|
for i, f in enumerate(old):
|
|
idx = combos[i].currentIndex()
|
|
if idx == len(new):
|
|
# ignore
|
|
map[f['ord']] = None
|
|
else:
|
|
f2 = new[idx]
|
|
map[f['ord']] = f2['ord']
|
|
return map
|
|
|
|
def getFieldMap(self):
|
|
return self.getTemplateMap(
|
|
old=self.oldModel['flds'],
|
|
combos=self.fcombos,
|
|
new=self.targetModel['flds'])
|
|
|
|
def cleanup(self):
|
|
remHook("reset", self.onReset)
|
|
remHook("currentModelChanged", self.onReset)
|
|
self.modelChooser.cleanup()
|
|
saveGeom(self, "changeModel")
|
|
|
|
def reject(self):
|
|
self.cleanup()
|
|
return QDialog.reject(self)
|
|
|
|
def accept(self):
|
|
# check maps
|
|
fmap = self.getFieldMap()
|
|
cmap = self.getTemplateMap()
|
|
if any(True for c in list(cmap.values()) if c is None):
|
|
if not askUser(_("""\
|
|
Any cards mapped to nothing will be deleted. \
|
|
If a note has no remaining cards, it will be lost. \
|
|
Are you sure you want to continue?""")):
|
|
return
|
|
QDialog.accept(self)
|
|
self.browser.mw.checkpoint(_("Change Note Type"))
|
|
b = self.browser
|
|
b.mw.col.modSchema(check=True)
|
|
b.mw.progress.start()
|
|
b.model.beginReset()
|
|
mm = b.mw.col.models
|
|
mm.change(self.oldModel, self.nids, self.targetModel, fmap, cmap)
|
|
b.search()
|
|
b.model.endReset()
|
|
b.mw.progress.finish()
|
|
b.mw.reset()
|
|
self.cleanup()
|
|
|
|
def onHelp(self):
|
|
openHelp("browsermisc")
|
|
|