2019-02-05 04:59:03 +01:00
|
|
|
# Copyright: Ankitects Pty Ltd and contributors
|
2012-12-21 08:51:59 +01:00
|
|
|
# License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
2020-02-11 23:28:21 +01:00
|
|
|
from __future__ import annotations
|
|
|
|
|
2017-12-11 07:20:00 +01:00
|
|
|
import html
|
2019-12-20 10:19:03 +01:00
|
|
|
import time
|
2021-01-04 05:13:20 +01:00
|
|
|
from concurrent.futures import Future
|
2020-02-11 23:28:21 +01:00
|
|
|
from dataclasses import dataclass
|
2019-12-20 10:19:03 +01:00
|
|
|
from operator import itemgetter
|
2021-02-01 00:39:55 +01:00
|
|
|
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast
|
2019-12-19 12:11:12 +01:00
|
|
|
|
2020-03-29 21:10:30 +02:00
|
|
|
import aqt
|
2019-12-20 10:19:03 +01:00
|
|
|
import aqt.forms
|
2020-01-15 22:41:23 +01:00
|
|
|
from anki.cards import Card
|
2021-02-11 10:57:19 +01:00
|
|
|
from anki.collection import Collection, Config, SearchNode
|
2019-12-20 10:19:03 +01:00
|
|
|
from anki.consts import *
|
2021-01-31 06:55:08 +01:00
|
|
|
from anki.errors import InvalidInput
|
2020-11-18 04:48:23 +01:00
|
|
|
from anki.lang import without_unicode_isolation
|
2020-01-17 01:17:33 +01:00
|
|
|
from anki.models import NoteType
|
2020-01-15 22:53:12 +01:00
|
|
|
from anki.notes import Note
|
2020-06-15 06:14:18 +02:00
|
|
|
from anki.stats import CardStats
|
2020-09-03 09:42:46 +02:00
|
|
|
from anki.utils import htmlToTextLine, ids2str, isMac, isWin
|
2021-02-05 09:50:01 +01:00
|
|
|
from aqt import AnkiQt, colors, gui_hooks
|
2020-01-15 22:41:23 +01:00
|
|
|
from aqt.editor import Editor
|
2020-02-10 04:15:19 +01:00
|
|
|
from aqt.exporting import ExportDialog
|
2020-08-16 18:49:51 +02:00
|
|
|
from aqt.main import ResetReason
|
2020-07-26 21:16:06 +02:00
|
|
|
from aqt.previewer import BrowserPreviewer as PreviewDialog
|
|
|
|
from aqt.previewer import Previewer
|
2013-05-03 10:52:46 +02:00
|
|
|
from aqt.qt import *
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
from aqt.scheduling import forget_cards, set_due_date_dialog
|
2021-02-25 11:03:57 +01:00
|
|
|
from aqt.sidebar import SidebarSearchBar, SidebarToolbar, SidebarTreeView
|
2020-01-23 06:08:10 +01:00
|
|
|
from aqt.theme import theme_manager
|
2019-12-23 01:34:10 +01:00
|
|
|
from aqt.utils import (
|
2020-11-17 08:42:43 +01:00
|
|
|
TR,
|
2021-01-25 14:45:47 +01:00
|
|
|
HelpPage,
|
2019-12-23 01:34:10 +01:00
|
|
|
askUser,
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button,
|
2019-12-23 01:34:10 +01:00
|
|
|
getTag,
|
|
|
|
openHelp,
|
|
|
|
qtMenuShortcutWorkaround,
|
2020-06-05 03:39:53 +02:00
|
|
|
restore_combo_history,
|
2020-06-08 20:54:20 +02:00
|
|
|
restore_combo_index_for_session,
|
2020-06-05 03:39:53 +02:00
|
|
|
restore_is_checked,
|
2019-12-23 01:34:10 +01:00
|
|
|
restoreGeom,
|
|
|
|
restoreHeader,
|
|
|
|
restoreSplitter,
|
|
|
|
restoreState,
|
2020-06-05 03:39:53 +02:00
|
|
|
save_combo_history,
|
2020-06-08 20:54:20 +02:00
|
|
|
save_combo_index_for_session,
|
2021-03-11 22:24:24 +01:00
|
|
|
save_editor,
|
2020-06-05 03:39:53 +02:00
|
|
|
save_is_checked,
|
2019-12-23 01:34:10 +01:00
|
|
|
saveGeom,
|
|
|
|
saveHeader,
|
|
|
|
saveSplitter,
|
|
|
|
saveState,
|
|
|
|
shortcut,
|
2021-01-25 23:19:19 +01:00
|
|
|
show_invalid_search_error,
|
2019-12-23 01:34:10 +01:00
|
|
|
showInfo,
|
|
|
|
showWarning,
|
|
|
|
tooltip,
|
2020-02-17 05:41:01 +01:00
|
|
|
tr,
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
from aqt.webview import AnkiWebView
|
|
|
|
|
2020-02-08 23:59:29 +01:00
|
|
|
|
2020-02-11 23:28:21 +01:00
|
|
|
@dataclass
|
|
|
|
class FindDupesDialog:
|
|
|
|
dialog: QDialog
|
|
|
|
browser: Browser
|
2020-02-08 23:59:29 +01:00
|
|
|
|
|
|
|
|
2020-03-21 07:38:46 +01:00
|
|
|
@dataclass
|
|
|
|
class SearchContext:
|
|
|
|
search: str
|
2020-08-11 22:30:03 +02:00
|
|
|
browser: Browser
|
2020-03-21 08:38:09 +01:00
|
|
|
order: Union[bool, str] = True
|
2020-03-21 07:38:46 +01:00
|
|
|
# if set, provided card ids will be used instead of the regular search
|
|
|
|
card_ids: Optional[Sequence[int]] = None
|
|
|
|
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Data model
|
|
|
|
##########################################################################
|
|
|
|
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
class DataModel(QAbstractTableModel):
|
2021-02-01 00:39:55 +01:00
|
|
|
def __init__(self, browser: Browser) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
QAbstractTableModel.__init__(self)
|
|
|
|
self.browser = browser
|
|
|
|
self.col = browser.col
|
|
|
|
self.sortKey = None
|
2020-04-05 13:38:58 +02:00
|
|
|
self.activeCols = self.col.get_config(
|
2019-12-23 01:34:10 +01:00
|
|
|
"activeCols", ["noteFld", "template", "cardDue", "deck"]
|
|
|
|
)
|
2020-03-21 07:38:46 +01:00
|
|
|
self.cards: Sequence[int] = []
|
2020-02-23 09:47:16 +01:00
|
|
|
self.cardObjs: Dict[int, Card] = {}
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-03-17 05:50:25 +01:00
|
|
|
def getCard(self, index: QModelIndex) -> Card:
|
2012-12-21 08:51:59 +01:00
|
|
|
id = self.cards[index.row()]
|
|
|
|
if not id in self.cardObjs:
|
2013-10-30 14:42:32 +01:00
|
|
|
self.cardObjs[id] = self.col.getCard(id)
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.cardObjs[id]
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def refreshNote(self, note: Note) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
refresh = False
|
|
|
|
for c in note.cards():
|
|
|
|
if c.id in self.cardObjs:
|
|
|
|
del self.cardObjs[c.id]
|
|
|
|
refresh = True
|
|
|
|
if refresh:
|
2020-07-26 01:25:39 +02:00
|
|
|
self.layoutChanged.emit() # type: ignore
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Model interface
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
|
2017-02-23 07:21:00 +01:00
|
|
|
if parent and parent.isValid():
|
2017-02-19 05:30:35 +01:00
|
|
|
return 0
|
2012-12-21 08:51:59 +01:00
|
|
|
return len(self.cards)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
|
2017-02-23 07:21:00 +01:00
|
|
|
if parent and parent.isValid():
|
2017-02-19 05:30:35 +01:00
|
|
|
return 0
|
2012-12-21 08:51:59 +01:00
|
|
|
return len(self.activeCols)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def data(self, index: QModelIndex = QModelIndex(), role: int = 0) -> Any:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not index.isValid():
|
|
|
|
return
|
|
|
|
if role == Qt.FontRole:
|
2019-12-23 01:34:10 +01:00
|
|
|
if self.activeCols[index.column()] not in ("question", "answer", "noteFld"):
|
2012-12-22 02:10:52 +01:00
|
|
|
return
|
|
|
|
c = self.getCard(index)
|
|
|
|
t = c.template()
|
2017-07-29 08:00:02 +02:00
|
|
|
if not t.get("bfont"):
|
|
|
|
return
|
|
|
|
f = QFont()
|
2020-07-26 01:25:39 +02:00
|
|
|
f.setFamily(cast(str, t.get("bfont", "arial")))
|
|
|
|
f.setPixelSize(cast(int, t.get("bsize", 12)))
|
2012-12-22 02:10:52 +01:00
|
|
|
return f
|
2017-07-29 08:00:02 +02:00
|
|
|
|
2012-12-22 02:10:52 +01:00
|
|
|
elif role == Qt.TextAlignmentRole:
|
2020-07-26 01:25:39 +02:00
|
|
|
align: Union[Qt.AlignmentFlag, int] = Qt.AlignVCenter
|
2019-12-23 01:34:10 +01:00
|
|
|
if self.activeCols[index.column()] not in (
|
|
|
|
"question",
|
|
|
|
"answer",
|
|
|
|
"template",
|
|
|
|
"deck",
|
|
|
|
"noteFld",
|
|
|
|
"note",
|
2020-04-01 05:29:42 +02:00
|
|
|
"noteTags",
|
2019-12-23 01:34:10 +01:00
|
|
|
):
|
2012-12-21 08:51:59 +01:00
|
|
|
align |= Qt.AlignHCenter
|
|
|
|
return align
|
|
|
|
elif role == Qt.DisplayRole or role == Qt.EditRole:
|
|
|
|
return self.columnData(index)
|
|
|
|
else:
|
|
|
|
return
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def headerData(
|
|
|
|
self, section: int, orientation: Qt.Orientation, role: int = 0
|
|
|
|
) -> Optional[str]:
|
2012-12-21 08:51:59 +01:00
|
|
|
if orientation == Qt.Vertical:
|
2021-02-01 00:39:55 +01:00
|
|
|
return None
|
2012-12-21 08:51:59 +01:00
|
|
|
elif role == Qt.DisplayRole and section < len(self.activeCols):
|
|
|
|
type = self.columnType(section)
|
2014-01-13 11:07:34 +01:00
|
|
|
txt = None
|
2012-12-21 08:51:59 +01:00
|
|
|
for stype, name in self.browser.columns:
|
|
|
|
if type == stype:
|
|
|
|
txt = name
|
|
|
|
break
|
2019-12-12 00:53:42 +01:00
|
|
|
# give the user a hint an invalid column was added by an add-on
|
2014-01-13 11:07:34 +01:00
|
|
|
if not txt:
|
2020-11-17 08:42:43 +01:00
|
|
|
txt = tr(TR.BROWSING_ADDON)
|
2012-12-21 08:51:59 +01:00
|
|
|
return txt
|
|
|
|
else:
|
2021-02-01 00:39:55 +01:00
|
|
|
return None
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def flags(self, index: QModelIndex) -> Qt.ItemFlags:
|
|
|
|
return cast(Qt.ItemFlags, Qt.ItemIsEnabled | Qt.ItemIsSelectable)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Filtering
|
|
|
|
######################################################################
|
|
|
|
|
2020-03-21 07:38:46 +01:00
|
|
|
def search(self, txt: str) -> None:
|
2016-07-14 12:23:44 +02:00
|
|
|
self.beginReset()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.cards = []
|
2017-02-02 12:00:58 +01:00
|
|
|
try:
|
2020-08-11 22:30:03 +02:00
|
|
|
ctx = SearchContext(search=txt, browser=self.browser)
|
2020-03-21 07:38:46 +01:00
|
|
|
gui_hooks.browser_will_search(ctx)
|
|
|
|
if ctx.card_ids is None:
|
2020-05-25 08:54:57 +02:00
|
|
|
ctx.card_ids = self.col.find_cards(ctx.search, order=ctx.order)
|
2020-03-21 07:38:46 +01:00
|
|
|
gui_hooks.browser_did_search(ctx)
|
|
|
|
self.cards = ctx.card_ids
|
2021-01-29 23:05:51 +01:00
|
|
|
except Exception as err:
|
|
|
|
raise err
|
2020-03-20 09:33:35 +01:00
|
|
|
finally:
|
|
|
|
self.endReset()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def reset(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.beginReset()
|
|
|
|
self.endReset()
|
|
|
|
|
2016-07-14 12:23:44 +02:00
|
|
|
# caller must have called editor.saveNow() before calling this or .reset()
|
2021-02-01 00:39:55 +01:00
|
|
|
def beginReset(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.browser.editor.setNote(None, hide=False)
|
|
|
|
self.browser.mw.progress.start()
|
|
|
|
self.saveSelection()
|
|
|
|
self.beginResetModel()
|
|
|
|
self.cardObjs = {}
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def endReset(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.endResetModel()
|
|
|
|
self.restoreSelection()
|
|
|
|
self.browser.mw.progress.finish()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def reverse(self) -> None:
|
2016-07-14 12:23:44 +02:00
|
|
|
self.browser.editor.saveNow(self._reverse)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _reverse(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.beginReset()
|
2020-03-21 07:57:33 +01:00
|
|
|
self.cards = list(reversed(self.cards))
|
2012-12-21 08:51:59 +01:00
|
|
|
self.endReset()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def saveSelection(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
cards = self.browser.selectedCards()
|
2021-02-11 00:37:38 +01:00
|
|
|
self.selectedCards = {id: True for id in cards}
|
2019-12-23 01:34:10 +01:00
|
|
|
if getattr(self.browser, "card", None):
|
2012-12-21 08:51:59 +01:00
|
|
|
self.focusedCard = self.browser.card.id
|
|
|
|
else:
|
|
|
|
self.focusedCard = None
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def restoreSelection(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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:
|
2020-04-11 07:54:52 +02:00
|
|
|
row = idx.row()
|
|
|
|
pos = tv.rowViewportPosition(row)
|
|
|
|
visible = pos >= 0 and pos < tv.viewport().height()
|
|
|
|
tv.selectRow(row)
|
|
|
|
|
2020-04-01 03:01:20 +02:00
|
|
|
# we save and then restore the horizontal scroll position because
|
|
|
|
# scrollTo() also scrolls horizontally which is confusing
|
2020-04-11 07:54:52 +02:00
|
|
|
if not visible:
|
|
|
|
h = tv.horizontalScrollBar().value()
|
|
|
|
tv.scrollTo(idx, tv.PositionAtCenter)
|
|
|
|
tv.horizontalScrollBar().setValue(h)
|
2012-12-21 08:51:59 +01:00
|
|
|
if count < 500:
|
|
|
|
# discard large selections; they're too slow
|
2019-12-23 01:34:10 +01:00
|
|
|
sm.select(
|
|
|
|
items, QItemSelectionModel.SelectCurrent | QItemSelectionModel.Rows
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
|
|
|
tv.selectRow(0)
|
|
|
|
|
|
|
|
# Column data
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def columnType(self, column: int) -> str:
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.activeCols[column]
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def time_format(self) -> str:
|
2020-03-19 22:59:59 +01:00
|
|
|
return "%Y-%m-%d"
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def columnData(self, index: QModelIndex) -> str:
|
2012-12-21 08:51:59 +01:00
|
|
|
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()
|
2017-03-14 07:48:40 +01:00
|
|
|
return htmlToTextLine(f.fields[self.col.models.sortIdx(f.model())])
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "template":
|
2019-12-23 01:34:10 +01:00
|
|
|
t = c.template()["name"]
|
|
|
|
if c.model()["type"] == MODEL_CLOZE:
|
2020-07-26 01:25:39 +02:00
|
|
|
t = f"{t} {c.ord + 1}"
|
2021-02-01 00:39:55 +01:00
|
|
|
return cast(str, t)
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "cardDue":
|
|
|
|
# catch invalid dates
|
|
|
|
try:
|
|
|
|
t = self.nextDue(c, index)
|
|
|
|
except:
|
|
|
|
t = ""
|
|
|
|
if c.queue < 0:
|
2020-07-26 01:25:39 +02:00
|
|
|
t = f"({t})"
|
2012-12-21 08:51:59 +01:00
|
|
|
return t
|
|
|
|
elif type == "noteCrt":
|
2020-03-19 22:59:59 +01:00
|
|
|
return time.strftime(self.time_format(), time.localtime(c.note().id / 1000))
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "noteMod":
|
2020-03-19 22:59:59 +01:00
|
|
|
return time.strftime(self.time_format(), time.localtime(c.note().mod))
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "cardMod":
|
2020-03-19 22:59:59 +01:00
|
|
|
return time.strftime(self.time_format(), time.localtime(c.mod))
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "cardReps":
|
|
|
|
return str(c.reps)
|
|
|
|
elif type == "cardLapses":
|
|
|
|
return str(c.lapses)
|
2013-09-03 20:20:20 +02:00
|
|
|
elif type == "noteTags":
|
2013-10-08 00:42:06 +02:00
|
|
|
return " ".join(c.note().tags)
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "note":
|
2019-12-23 01:34:10 +01:00
|
|
|
return c.model()["name"]
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "cardIvl":
|
2020-03-17 05:50:25 +01:00
|
|
|
if c.type == CARD_TYPE_NEW:
|
2020-11-17 08:42:43 +01:00
|
|
|
return tr(TR.BROWSING_NEW)
|
2020-03-17 05:50:25 +01:00
|
|
|
elif c.type == CARD_TYPE_LRN:
|
2020-11-17 08:42:43 +01:00
|
|
|
return tr(TR.BROWSING_LEARNING)
|
2020-05-24 00:36:50 +02:00
|
|
|
return self.col.format_timespan(c.ivl * 86400)
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "cardEase":
|
2020-03-17 05:50:25 +01:00
|
|
|
if c.type == CARD_TYPE_NEW:
|
2020-11-17 08:42:43 +01:00
|
|
|
return tr(TR.BROWSING_NEW)
|
2019-12-23 01:34:10 +01:00
|
|
|
return "%d%%" % (c.factor / 10)
|
2012-12-21 08:51:59 +01:00
|
|
|
elif type == "deck":
|
|
|
|
if c.odid:
|
|
|
|
# in a cram deck
|
|
|
|
return "%s (%s)" % (
|
|
|
|
self.browser.mw.col.decks.name(c.did),
|
2019-12-23 01:34:10 +01:00
|
|
|
self.browser.mw.col.decks.name(c.odid),
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
# normal deck
|
|
|
|
return self.browser.mw.col.decks.name(c.did)
|
2021-02-01 00:39:55 +01:00
|
|
|
else:
|
|
|
|
return ""
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def question(self, c: Card) -> str:
|
2017-03-14 07:48:40 +01:00
|
|
|
return htmlToTextLine(c.q(browser=True))
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def answer(self, c: Card) -> str:
|
2019-12-23 01:34:10 +01:00
|
|
|
if c.template().get("bafmt"):
|
2012-12-21 08:51:59 +01:00
|
|
|
# they have provided a template, use it verbatim
|
|
|
|
c.q(browser=True)
|
2017-03-14 07:48:40 +01:00
|
|
|
return htmlToTextLine(c.a())
|
2012-12-21 08:51:59 +01:00
|
|
|
# need to strip question from answer
|
|
|
|
q = self.question(c)
|
2017-03-14 07:48:40 +01:00
|
|
|
a = htmlToTextLine(c.a())
|
2012-12-21 08:51:59 +01:00
|
|
|
if a.startswith(q):
|
2019-12-23 01:34:10 +01:00
|
|
|
return a[len(q) :].strip()
|
2012-12-21 08:51:59 +01:00
|
|
|
return a
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def nextDue(self, c: Card, index: QModelIndex) -> str:
|
|
|
|
date: float
|
2012-12-21 08:51:59 +01:00
|
|
|
if c.odid:
|
2020-11-17 08:42:43 +01:00
|
|
|
return tr(TR.BROWSING_FILTERED)
|
2020-02-02 10:28:04 +01:00
|
|
|
elif c.queue == QUEUE_TYPE_LRN:
|
2012-12-21 08:51:59 +01:00
|
|
|
date = c.due
|
2020-02-02 10:19:45 +01:00
|
|
|
elif c.queue == QUEUE_TYPE_NEW or c.type == CARD_TYPE_NEW:
|
2020-02-27 03:25:19 +01:00
|
|
|
return tr(TR.STATISTICS_DUE_FOR_NEW_CARD, number=c.due)
|
2020-01-31 09:58:03 +01:00
|
|
|
elif c.queue in (QUEUE_TYPE_REV, QUEUE_TYPE_DAY_LEARN_RELEARN) or (
|
|
|
|
c.type == CARD_TYPE_REV and c.queue < 0
|
|
|
|
):
|
2019-12-23 01:34:10 +01:00
|
|
|
date = time.time() + ((c.due - self.col.sched.today) * 86400)
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
|
|
|
return ""
|
2020-03-19 22:59:59 +01:00
|
|
|
return time.strftime(self.time_format(), time.localtime(date))
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def isRTL(self, index: QModelIndex) -> bool:
|
2018-08-08 02:39:54 +02:00
|
|
|
col = index.column()
|
|
|
|
type = self.columnType(col)
|
|
|
|
if type != "noteFld":
|
|
|
|
return False
|
|
|
|
|
|
|
|
c = self.getCard(index)
|
|
|
|
nt = c.note().model()
|
2019-12-23 01:34:10 +01:00
|
|
|
return nt["flds"][self.col.models.sortIdx(nt)]["rtl"]
|
|
|
|
|
2018-08-08 02:39:54 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Line painter
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
class StatusDelegate(QItemDelegate):
|
2021-02-01 00:39:55 +01:00
|
|
|
def __init__(self, browser: Browser, model: DataModel) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
QItemDelegate.__init__(self, browser)
|
2013-01-28 22:45:29 +01:00
|
|
|
self.browser = browser
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model = model
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def paint(
|
|
|
|
self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex
|
|
|
|
) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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
|
2017-08-12 08:08:10 +02:00
|
|
|
|
2018-08-08 02:39:54 +02:00
|
|
|
if self.model.isRTL(index):
|
|
|
|
option.direction = Qt.RightToLeft
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
col = None
|
2021-03-06 15:17:17 +01:00
|
|
|
if c.user_flag() > 0:
|
|
|
|
col = getattr(colors, f"FLAG{c.user_flag()}_BG")
|
2021-03-05 13:45:55 +01:00
|
|
|
elif c.note().has_tag("Marked"):
|
2021-02-05 09:50:01 +01:00
|
|
|
col = colors.MARKED_BG
|
2020-03-17 05:50:25 +01:00
|
|
|
elif c.queue == QUEUE_TYPE_SUSPENDED:
|
2021-02-05 09:50:01 +01:00
|
|
|
col = colors.SUSPENDED_BG
|
2012-12-21 08:51:59 +01:00
|
|
|
if col:
|
2021-02-05 09:50:01 +01:00
|
|
|
brush = QBrush(theme_manager.qcolor(col))
|
2012-12-21 08:51:59 +01:00
|
|
|
painter.save()
|
|
|
|
painter.fillRect(option.rect, brush)
|
|
|
|
painter.restore()
|
2017-08-12 08:08:10 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
return QItemDelegate.paint(self, painter, option, index)
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Browser window
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
# fixme: respond to reset+edit hooks
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
class Browser(QMainWindow):
|
2019-12-20 08:55:19 +01:00
|
|
|
model: DataModel
|
|
|
|
mw: AnkiQt
|
2020-05-20 09:56:52 +02:00
|
|
|
col: Collection
|
2020-01-15 22:41:23 +01:00
|
|
|
editor: Optional[Editor]
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 11:54:28 +01:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
mw: AnkiQt,
|
|
|
|
card: Optional[Card] = None,
|
2021-02-11 10:57:19 +01:00
|
|
|
search: Optional[Tuple[Union[str, SearchNode]]] = None,
|
2021-02-01 11:54:28 +01:00
|
|
|
) -> None:
|
2021-02-02 09:48:55 +01:00
|
|
|
"""
|
|
|
|
card : try to search for its note and select it
|
|
|
|
search: set and perform search; caller must ensure validity
|
|
|
|
"""
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
QMainWindow.__init__(self, None, Qt.Window)
|
|
|
|
self.mw = mw
|
|
|
|
self.col = self.mw.col
|
|
|
|
self.lastFilter = ""
|
2020-07-26 01:25:39 +02:00
|
|
|
self.focusTo: Optional[int] = None
|
|
|
|
self._previewer: Optional[Previewer] = None
|
2016-07-14 12:23:44 +02:00
|
|
|
self._closeEventHasCleanedUp = False
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form = aqt.forms.browser.Ui_Dialog()
|
|
|
|
self.form.setupUi(self)
|
2017-08-13 11:11:40 +02:00
|
|
|
self.setupSidebar()
|
2012-12-21 08:51:59 +01:00
|
|
|
restoreGeom(self, "editor", 0)
|
|
|
|
restoreState(self, "editor")
|
|
|
|
restoreSplitter(self.form.splitter, "editor3")
|
|
|
|
self.form.splitter.setChildrenCollapsible(False)
|
2020-01-15 22:41:23 +01:00
|
|
|
self.card: Optional[Card] = None
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setupColumns()
|
|
|
|
self.setupTable()
|
|
|
|
self.setupMenus()
|
|
|
|
self.setupHeaders()
|
|
|
|
self.setupHooks()
|
|
|
|
self.setupEditor()
|
|
|
|
self.updateFont()
|
|
|
|
self.onUndoState(self.mw.form.actionUndo.isEnabled())
|
2021-02-01 11:54:28 +01:00
|
|
|
self.setupSearch(card, search)
|
2020-02-29 17:02:51 +01:00
|
|
|
gui_hooks.browser_will_show(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.show()
|
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def setupMenus(self) -> None:
|
2019-03-04 07:01:10 +01:00
|
|
|
# pylint: disable=unnecessary-lambda
|
2012-12-21 08:51:59 +01:00
|
|
|
# actions
|
2016-05-31 10:51:40 +02:00
|
|
|
f = self.form
|
2017-08-11 06:40:51 +02:00
|
|
|
# edit
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionUndo.triggered, self.mw.onUndo)
|
|
|
|
qconnect(f.actionInvertSelection.triggered, self.invertSelection)
|
|
|
|
qconnect(f.actionSelectNotes.triggered, self.selectNotes)
|
2017-08-11 06:40:51 +02:00
|
|
|
if not isMac:
|
|
|
|
f.actionClose.setVisible(False)
|
2021-02-01 12:09:37 +01:00
|
|
|
qconnect(f.actionCreateFilteredDeck.triggered, self.createFilteredDeck)
|
2021-02-02 09:29:09 +01:00
|
|
|
f.actionCreateFilteredDeck.setShortcuts(["Ctrl+G", "Ctrl+Alt+G"])
|
2017-08-11 06:40:51 +02:00
|
|
|
# notes
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionAdd.triggered, self.mw.onAddCard)
|
2021-03-05 11:47:51 +01:00
|
|
|
qconnect(f.actionAdd_Tags.triggered, lambda: self.add_tags_to_selected_notes())
|
|
|
|
qconnect(
|
|
|
|
f.actionRemove_Tags.triggered,
|
|
|
|
lambda: self.remove_tags_from_selected_notes(),
|
|
|
|
)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionClear_Unused_Tags.triggered, self.clearUnusedTags)
|
|
|
|
qconnect(f.actionToggle_Mark.triggered, lambda: self.onMark())
|
|
|
|
qconnect(f.actionChangeModel.triggered, self.onChangeModel)
|
|
|
|
qconnect(f.actionFindDuplicates.triggered, self.onFindDupes)
|
|
|
|
qconnect(f.actionFindReplace.triggered, self.onFindReplace)
|
|
|
|
qconnect(f.actionManage_Note_Types.triggered, self.mw.onNoteTypes)
|
|
|
|
qconnect(f.actionDelete.triggered, self.deleteNotes)
|
2017-08-11 06:40:51 +02:00
|
|
|
# cards
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionChange_Deck.triggered, self.setDeck)
|
|
|
|
qconnect(f.action_Info.triggered, self.showCardInfo)
|
|
|
|
qconnect(f.actionReposition.triggered, self.reposition)
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
qconnect(f.action_set_due_date.triggered, self.set_due_date)
|
|
|
|
qconnect(f.action_forget.triggered, self.forget_cards)
|
2021-03-04 13:14:35 +01:00
|
|
|
qconnect(f.actionToggle_Suspend.triggered, self.suspend_selected_cards)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionRed_Flag.triggered, lambda: self.onSetFlag(1))
|
|
|
|
qconnect(f.actionOrange_Flag.triggered, lambda: self.onSetFlag(2))
|
|
|
|
qconnect(f.actionGreen_Flag.triggered, lambda: self.onSetFlag(3))
|
|
|
|
qconnect(f.actionBlue_Flag.triggered, lambda: self.onSetFlag(4))
|
|
|
|
qconnect(f.actionExport.triggered, lambda: self._on_export_notes())
|
2012-12-21 08:51:59 +01:00
|
|
|
# jumps
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionPreviousCard.triggered, self.onPreviousCard)
|
|
|
|
qconnect(f.actionNextCard.triggered, self.onNextCard)
|
|
|
|
qconnect(f.actionFirstCard.triggered, self.onFirstCard)
|
|
|
|
qconnect(f.actionLastCard.triggered, self.onLastCard)
|
|
|
|
qconnect(f.actionFind.triggered, self.onFind)
|
|
|
|
qconnect(f.actionNote.triggered, self.onNote)
|
|
|
|
qconnect(f.actionSidebar.triggered, self.focusSidebar)
|
|
|
|
qconnect(f.actionCardList.triggered, self.onCardList)
|
2012-12-21 08:51:59 +01:00
|
|
|
# help
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(f.actionGuide.triggered, self.onHelp)
|
2012-12-21 08:51:59 +01:00
|
|
|
# keyboard shortcut for shift+home/end
|
|
|
|
self.pgUpCut = QShortcut(QKeySequence("Shift+Home"), self)
|
2020-01-15 22:41:23 +01:00
|
|
|
qconnect(self.pgUpCut.activated, self.onFirstCard)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.pgDownCut = QShortcut(QKeySequence("Shift+End"), self)
|
2020-01-15 22:41:23 +01:00
|
|
|
qconnect(self.pgDownCut.activated, self.onLastCard)
|
2012-12-21 08:51:59 +01:00
|
|
|
# add-on hook
|
2020-01-15 08:18:11 +01:00
|
|
|
gui_hooks.browser_menus_did_init(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.mw.maybeHideAccelerators(self)
|
|
|
|
|
2017-12-14 05:49:51 +01:00
|
|
|
# context menu
|
|
|
|
self.form.tableView.setContextMenuPolicy(Qt.CustomContextMenu)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(self.form.tableView.customContextMenuRequested, self.onContextMenu)
|
2017-12-14 05:49:51 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onContextMenu(self, _point: QPoint) -> None:
|
2017-12-14 05:49:51 +01:00
|
|
|
m = QMenu()
|
|
|
|
for act in self.form.menu_Cards.actions():
|
|
|
|
m.addAction(act)
|
|
|
|
m.addSeparator()
|
|
|
|
for act in self.form.menu_Notes.actions():
|
|
|
|
m.addAction(act)
|
2020-01-15 22:53:12 +01:00
|
|
|
gui_hooks.browser_will_show_context_menu(self, m)
|
2019-02-05 05:37:07 +01:00
|
|
|
qtMenuShortcutWorkaround(m)
|
2017-12-14 05:49:51 +01:00
|
|
|
m.exec_(QCursor.pos())
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def updateFont(self) -> None:
|
2013-05-23 07:12:04 +02:00
|
|
|
# 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():
|
2019-12-23 01:34:10 +01:00
|
|
|
for t in m["tmpls"]:
|
2013-05-23 07:12:04 +02:00
|
|
|
bsize = t.get("bsize", 0)
|
|
|
|
if bsize > curmax:
|
|
|
|
curmax = bsize
|
2019-12-23 01:34:10 +01:00
|
|
|
self.form.tableView.verticalHeader().setDefaultSectionSize(curmax + 6)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def closeEvent(self, evt: QCloseEvent) -> None:
|
2017-08-16 04:45:33 +02:00
|
|
|
if self._closeEventHasCleanedUp:
|
2016-07-14 12:23:44 +02:00
|
|
|
evt.accept()
|
2017-08-16 04:45:33 +02:00
|
|
|
return
|
|
|
|
self.editor.saveNow(self._closeWindow)
|
|
|
|
evt.ignore()
|
2016-07-14 12:23:44 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _closeWindow(self) -> None:
|
2020-04-10 10:42:28 +02:00
|
|
|
self._cleanup_preview()
|
2017-08-16 04:45:33 +02:00
|
|
|
self.editor.cleanup()
|
2012-12-21 08:51:59 +01:00
|
|
|
saveSplitter(self.form.splitter, "editor3")
|
|
|
|
saveGeom(self, "editor")
|
|
|
|
saveState(self, "editor")
|
2014-03-14 07:29:48 +01:00
|
|
|
saveHeader(self.form.tableView.horizontalHeader(), "editor")
|
2012-12-21 08:51:59 +01:00
|
|
|
self.teardownHooks()
|
|
|
|
self.mw.maybeReset()
|
2017-08-16 04:45:33 +02:00
|
|
|
aqt.dialogs.markClosed("Browser")
|
2016-07-14 12:23:44 +02:00
|
|
|
self._closeEventHasCleanedUp = True
|
2021-03-05 04:07:52 +01:00
|
|
|
self.mw.deferred_delete_and_garbage_collect(self)
|
2017-08-16 04:45:33 +02:00
|
|
|
self.close()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def closeWithCallback(self, onsuccess: Callable) -> None:
|
2021-03-11 22:24:24 +01:00
|
|
|
self._closeWindow()
|
|
|
|
onsuccess()
|
2013-04-11 12:23:32 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def keyPressEvent(self, evt: QKeyEvent) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if evt.key() == Qt.Key_Escape:
|
|
|
|
self.close()
|
2017-08-13 11:11:40 +02:00
|
|
|
else:
|
|
|
|
super().keyPressEvent(evt)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setupColumns(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.columns = [
|
2020-11-17 08:42:43 +01:00
|
|
|
("question", tr(TR.BROWSING_QUESTION)),
|
|
|
|
("answer", tr(TR.BROWSING_ANSWER)),
|
|
|
|
("template", tr(TR.BROWSING_CARD)),
|
|
|
|
("deck", tr(TR.DECKS_DECK)),
|
|
|
|
("noteFld", tr(TR.BROWSING_SORT_FIELD)),
|
|
|
|
("noteCrt", tr(TR.BROWSING_CREATED)),
|
2020-06-29 10:34:03 +02:00
|
|
|
("noteMod", tr(TR.SEARCH_NOTE_MODIFIED)),
|
|
|
|
("cardMod", tr(TR.SEARCH_CARD_MODIFIED)),
|
2020-02-27 03:25:19 +01:00
|
|
|
("cardDue", tr(TR.STATISTICS_DUE_DATE)),
|
2020-11-17 08:42:43 +01:00
|
|
|
("cardIvl", tr(TR.BROWSING_INTERVAL)),
|
|
|
|
("cardEase", tr(TR.BROWSING_EASE)),
|
|
|
|
("cardReps", tr(TR.SCHEDULING_REVIEWS)),
|
|
|
|
("cardLapses", tr(TR.SCHEDULING_LAPSES)),
|
|
|
|
("noteTags", tr(TR.EDITING_TAGS)),
|
|
|
|
("note", tr(TR.BROWSING_NOTE)),
|
2012-12-21 08:51:59 +01:00
|
|
|
]
|
|
|
|
self.columns.sort(key=itemgetter(1))
|
|
|
|
|
2021-02-01 11:54:28 +01:00
|
|
|
def reopen(
|
|
|
|
self,
|
|
|
|
_mw: AnkiQt,
|
|
|
|
card: Optional[Card] = None,
|
2021-02-11 10:57:19 +01:00
|
|
|
search: Optional[Tuple[Union[str, SearchNode]]] = None,
|
2021-02-01 11:54:28 +01:00
|
|
|
) -> None:
|
|
|
|
if search is not None:
|
|
|
|
self.search_for_terms(*search)
|
|
|
|
self.form.searchEdit.setFocus()
|
|
|
|
elif card:
|
|
|
|
self.show_single_card(card)
|
|
|
|
self.form.searchEdit.setFocus()
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Searching
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 11:54:28 +01:00
|
|
|
def setupSearch(
|
|
|
|
self,
|
|
|
|
card: Optional[Card] = None,
|
2021-02-11 10:57:19 +01:00
|
|
|
search: Optional[Tuple[Union[str, SearchNode]]] = None,
|
2021-02-01 23:33:41 +01:00
|
|
|
) -> None:
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(self.form.searchEdit.lineEdit().returnPressed, self.onSearchActivated)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.searchEdit.setCompleter(None)
|
2021-01-29 21:07:42 +01:00
|
|
|
self.form.searchEdit.lineEdit().setPlaceholderText(
|
|
|
|
tr(TR.BROWSING_SEARCH_BAR_HINT)
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2021-01-30 10:51:31 +01:00
|
|
|
self.form.searchEdit.addItems(self.mw.pm.profile["searchHistory"])
|
2021-02-01 11:54:28 +01:00
|
|
|
if search is not None:
|
|
|
|
self.search_for_terms(*search)
|
|
|
|
elif card:
|
|
|
|
self.show_single_card(card)
|
|
|
|
else:
|
|
|
|
self.search_for(
|
2021-02-11 10:57:19 +01:00
|
|
|
self.col.build_search_string(SearchNode(deck="current")), ""
|
2021-02-01 11:54:28 +01:00
|
|
|
)
|
2016-07-14 12:23:44 +02:00
|
|
|
self.form.searchEdit.setFocus()
|
|
|
|
|
|
|
|
# search triggered by user
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onSearchActivated(self) -> None:
|
2021-01-29 21:07:42 +01:00
|
|
|
text = self.form.searchEdit.lineEdit().text()
|
2021-01-30 10:51:31 +01:00
|
|
|
try:
|
|
|
|
normed = self.col.build_search_string(text)
|
|
|
|
except InvalidInput as err:
|
|
|
|
show_invalid_search_error(err)
|
|
|
|
else:
|
|
|
|
self.search_for(normed)
|
2021-01-29 23:05:51 +01:00
|
|
|
self.update_history()
|
2018-11-12 03:43:54 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def search_for(self, search: str, prompt: Optional[str] = None) -> None:
|
2021-01-30 11:05:48 +01:00
|
|
|
"""Keep track of search string so that we reuse identical search when
|
|
|
|
refreshing, rather than whatever is currently in the search field.
|
|
|
|
Optionally set the search bar to a different text than the actual search.
|
|
|
|
"""
|
2016-07-14 12:23:44 +02:00
|
|
|
|
2020-10-19 20:37:17 +02:00
|
|
|
self._lastSearchTxt = search
|
2021-01-30 10:51:31 +01:00
|
|
|
prompt = search if prompt == None else prompt
|
|
|
|
self.form.searchEdit.lineEdit().setText(prompt)
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
|
|
|
|
2021-02-09 01:50:39 +01:00
|
|
|
def current_search(self) -> str:
|
|
|
|
return self.form.searchEdit.lineEdit().text()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def search(self) -> None:
|
2021-01-30 10:51:31 +01:00
|
|
|
"""Search triggered programmatically. Caller must have saved note first."""
|
2016-07-14 12:23:44 +02:00
|
|
|
|
2021-01-29 23:05:51 +01:00
|
|
|
try:
|
|
|
|
self.model.search(self._lastSearchTxt)
|
2021-01-30 10:51:31 +01:00
|
|
|
except Exception as err:
|
2021-01-29 23:05:51 +01:00
|
|
|
show_invalid_search_error(err)
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.model.cards:
|
|
|
|
# no row change will fire
|
2016-07-14 12:23:44 +02:00
|
|
|
self._onRowChanged(None, None)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def update_history(self) -> None:
|
2019-12-23 01:34:10 +01:00
|
|
|
sh = self.mw.pm.profile["searchHistory"]
|
2021-01-29 23:05:51 +01:00
|
|
|
if self._lastSearchTxt in sh:
|
|
|
|
sh.remove(self._lastSearchTxt)
|
|
|
|
sh.insert(0, self._lastSearchTxt)
|
2012-12-21 08:51:59 +01:00
|
|
|
sh = sh[:30]
|
|
|
|
self.form.searchEdit.clear()
|
|
|
|
self.form.searchEdit.addItems(sh)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.mw.pm.profile["searchHistory"] = sh
|
2020-12-22 11:08:47 +01:00
|
|
|
|
2021-01-30 11:24:33 +01:00
|
|
|
def updateTitle(self) -> int:
|
2012-12-21 08:51:59 +01:00
|
|
|
selected = len(self.form.tableView.selectionModel().selectedRows())
|
|
|
|
cur = len(self.model.cards)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.setWindowTitle(
|
2020-11-18 04:40:21 +01:00
|
|
|
without_unicode_isolation(
|
|
|
|
tr(TR.BROWSING_WINDOW_TITLE, total=cur, selected=selected)
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
return selected
|
|
|
|
|
2021-02-11 10:57:19 +01:00
|
|
|
def search_for_terms(self, *search_terms: Union[str, SearchNode]) -> None:
|
2021-02-01 11:54:28 +01:00
|
|
|
search = self.col.build_search_string(*search_terms)
|
|
|
|
self.form.searchEdit.setEditText(search)
|
|
|
|
self.onSearchActivated()
|
2021-01-30 11:05:48 +01:00
|
|
|
|
2021-02-01 23:46:56 +01:00
|
|
|
def show_single_card(self, card: Card) -> None:
|
2021-02-01 11:54:28 +01:00
|
|
|
if card.nid:
|
2021-01-30 10:51:31 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def on_show_single_card() -> None:
|
2021-01-30 10:51:31 +01:00
|
|
|
self.card = card
|
2021-02-11 10:57:19 +01:00
|
|
|
search = self.col.build_search_string(SearchNode(nid=card.nid))
|
2021-01-30 10:51:31 +01:00
|
|
|
search = gui_hooks.default_search(search, card)
|
|
|
|
self.search_for(search, "")
|
|
|
|
self.focusCid(card.id)
|
|
|
|
|
|
|
|
self.editor.saveNow(on_show_single_card)
|
2021-01-29 21:07:42 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onReset(self) -> None:
|
2021-01-23 10:59:12 +01:00
|
|
|
self.sidebar.refresh()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.editor.setNote(None)
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Table view & editor
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setupTable(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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))
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(
|
|
|
|
self.form.tableView.selectionModel().selectionChanged, self.onRowChanged
|
|
|
|
)
|
2020-03-20 09:34:03 +01:00
|
|
|
self.form.tableView.setWordWrap(False)
|
2020-01-23 06:08:10 +01:00
|
|
|
if not theme_manager.night_mode:
|
|
|
|
self.form.tableView.setStyleSheet(
|
|
|
|
"QTableView{ selection-background-color: rgba(150, 150, 150, 50); "
|
|
|
|
"selection-color: black; }"
|
|
|
|
)
|
2020-02-02 03:01:27 +01:00
|
|
|
elif theme_manager.macos_dark_mode():
|
2021-02-05 09:50:01 +01:00
|
|
|
grid = colors.FRAME_BG
|
2020-02-02 04:09:02 +01:00
|
|
|
self.form.tableView.setStyleSheet(
|
|
|
|
f"""
|
2020-02-02 03:01:27 +01:00
|
|
|
QTableView {{ gridline-color: {grid} }}
|
2020-02-02 04:09:02 +01:00
|
|
|
"""
|
|
|
|
)
|
2018-09-24 09:29:19 +02:00
|
|
|
self.singleCard = False
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setupEditor(self) -> None:
|
|
|
|
def add_preview_button(leftbuttons: List[str], editor: Editor) -> None:
|
2021-01-10 00:00:19 +01:00
|
|
|
preview_shortcut = "Ctrl+Shift+P"
|
2021-01-10 01:44:08 +01:00
|
|
|
leftbuttons.insert(
|
|
|
|
0,
|
|
|
|
editor.addButton(
|
|
|
|
None,
|
|
|
|
"preview",
|
|
|
|
lambda _editor: self.onTogglePreview(),
|
|
|
|
tr(
|
|
|
|
TR.BROWSING_PREVIEW_SELECTED_CARD,
|
|
|
|
val=shortcut(preview_shortcut),
|
|
|
|
),
|
|
|
|
tr(TR.ACTIONS_PREVIEW),
|
|
|
|
id="previewButton",
|
|
|
|
keys=preview_shortcut,
|
|
|
|
disables=False,
|
|
|
|
rightside=False,
|
|
|
|
toggleable=True,
|
|
|
|
),
|
|
|
|
)
|
2021-01-09 22:34:53 +01:00
|
|
|
|
|
|
|
gui_hooks.editor_did_init_left_buttons.append(add_preview_button)
|
2019-12-23 01:34:10 +01:00
|
|
|
self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, self)
|
2021-01-09 22:34:53 +01:00
|
|
|
gui_hooks.editor_did_init_left_buttons.remove(add_preview_button)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onRowChanged(self, current: QItemSelection, previous: QItemSelection) -> None:
|
2021-03-11 22:24:24 +01:00
|
|
|
"""Update current note and hide/show editor."""
|
2020-04-02 11:44:51 +02:00
|
|
|
if self._closeEventHasCleanedUp:
|
|
|
|
return
|
2012-12-21 08:51:59 +01:00
|
|
|
update = self.updateTitle()
|
|
|
|
show = self.model.cards and update == 1
|
2020-03-23 18:16:39 +01:00
|
|
|
self.form.splitter.widget(1).setVisible(bool(show))
|
2017-08-31 12:38:12 +02:00
|
|
|
idx = self.form.tableView.selectionModel().currentIndex()
|
|
|
|
if idx.isValid():
|
|
|
|
self.card = self.model.getCard(idx)
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
if not show:
|
|
|
|
self.editor.setNote(None)
|
2013-05-10 08:02:58 +02:00
|
|
|
self.singleCard = False
|
2020-09-24 06:05:16 +02:00
|
|
|
self._renderPreview()
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
2017-08-05 07:15:19 +02:00
|
|
|
self.editor.setNote(self.card.note(reload=True), focusTo=self.focusTo)
|
|
|
|
self.focusTo = None
|
2020-03-04 17:41:26 +01:00
|
|
|
self.editor.card = self.card
|
2013-05-10 08:02:58 +02:00
|
|
|
self.singleCard = True
|
2018-11-12 03:10:50 +01:00
|
|
|
self._updateFlagsMenu()
|
2020-01-15 08:45:35 +01:00
|
|
|
gui_hooks.browser_did_change_row(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-01-15 22:53:12 +01:00
|
|
|
def refreshCurrentCard(self, note: Note) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.refreshNote(note)
|
2020-07-24 03:57:22 +02:00
|
|
|
self._renderPreview()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onLoadNote(self, editor: Editor) -> None:
|
2018-11-27 08:58:38 +01:00
|
|
|
self.refreshCurrentCard(editor.note)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def currentRow(self) -> int:
|
2013-05-03 10:52:46 +02:00
|
|
|
idx = self.form.tableView.selectionModel().currentIndex()
|
|
|
|
return idx.row()
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Headers & sorting
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setupHeaders(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
vh = self.form.tableView.verticalHeader()
|
|
|
|
hh = self.form.tableView.horizontalHeader()
|
|
|
|
if not isWin:
|
|
|
|
vh.hide()
|
|
|
|
hh.show()
|
2014-03-14 07:29:48 +01:00
|
|
|
restoreHeader(hh, "editor")
|
2012-12-21 08:51:59 +01:00
|
|
|
hh.setHighlightSections(False)
|
|
|
|
hh.setMinimumSectionSize(50)
|
2016-05-31 10:51:40 +02:00
|
|
|
hh.setSectionsMovable(True)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setColumnSizes()
|
|
|
|
hh.setContextMenuPolicy(Qt.CustomContextMenu)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(hh.customContextMenuRequested, self.onHeaderContext)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setSortIndicator()
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(hh.sortIndicatorChanged, self.onSortChanged)
|
|
|
|
qconnect(hh.sectionMoved, self.onColumnMoved)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onSortChanged(self, idx: int, ord: int) -> None:
|
2021-03-11 22:24:24 +01:00
|
|
|
ord = bool(ord)
|
2012-12-21 08:51:59 +01:00
|
|
|
type = self.model.activeCols[idx]
|
2020-03-20 22:55:53 +01:00
|
|
|
noSort = ("question", "answer")
|
2012-12-21 08:51:59 +01:00
|
|
|
if type in noSort:
|
2020-11-17 08:42:43 +01:00
|
|
|
showInfo(tr(TR.BROWSING_SORTING_ON_THIS_COLUMN_IS_NOT))
|
2019-12-23 01:34:10 +01:00
|
|
|
type = self.col.conf["sortType"]
|
|
|
|
if self.col.conf["sortType"] != type:
|
|
|
|
self.col.conf["sortType"] = type
|
2012-12-21 08:51:59 +01:00
|
|
|
# default to descending for non-text fields
|
|
|
|
if type == "noteFld":
|
|
|
|
ord = not ord
|
2021-02-08 05:10:05 +01:00
|
|
|
self.col.set_config_bool(Config.Bool.BROWSER_SORT_BACKWARDS, ord)
|
2020-03-20 06:44:35 +01:00
|
|
|
self.col.save()
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
2021-02-08 05:10:05 +01:00
|
|
|
if self.col.get_config_bool(Config.Bool.BROWSER_SORT_BACKWARDS) != ord:
|
|
|
|
self.col.set_config_bool(Config.Bool.BROWSER_SORT_BACKWARDS, ord)
|
2020-03-20 06:44:35 +01:00
|
|
|
self.col.save()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.reverse()
|
|
|
|
self.setSortIndicator()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setSortIndicator(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
hh = self.form.tableView.horizontalHeader()
|
2019-12-23 01:34:10 +01:00
|
|
|
type = self.col.conf["sortType"]
|
2012-12-21 08:51:59 +01:00
|
|
|
if type not in self.model.activeCols:
|
|
|
|
hh.setSortIndicatorShown(False)
|
|
|
|
return
|
|
|
|
idx = self.model.activeCols.index(type)
|
2021-02-08 05:10:05 +01:00
|
|
|
if self.col.get_config_bool(Config.Bool.BROWSER_SORT_BACKWARDS):
|
2012-12-21 08:51:59 +01:00
|
|
|
ord = Qt.DescendingOrder
|
|
|
|
else:
|
|
|
|
ord = Qt.AscendingOrder
|
|
|
|
hh.blockSignals(True)
|
|
|
|
hh.setSortIndicator(idx, ord)
|
|
|
|
hh.blockSignals(False)
|
|
|
|
hh.setSortIndicatorShown(True)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onHeaderContext(self, pos: QPoint) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(a.toggled, lambda b, t=type: self.toggleField(t))
|
2020-03-27 23:06:22 +01:00
|
|
|
gui_hooks.browser_header_will_show_context_menu(self, m)
|
2012-12-21 08:51:59 +01:00
|
|
|
m.exec_(gpos)
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def toggleField(self, type: str) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.beginReset()
|
|
|
|
if type in self.model.activeCols:
|
|
|
|
if len(self.model.activeCols) < 2:
|
2018-07-25 11:52:21 +02:00
|
|
|
self.model.endReset()
|
2021-02-01 00:39:55 +01:00
|
|
|
showInfo(tr(TR.BROWSING_YOU_MUST_HAVE_AT_LEAST_ONE))
|
|
|
|
return
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.activeCols.remove(type)
|
2019-12-23 01:34:10 +01:00
|
|
|
adding = False
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
|
|
|
self.model.activeCols.append(type)
|
2019-12-23 01:34:10 +01:00
|
|
|
adding = True
|
2020-06-02 05:39:15 +02:00
|
|
|
self.col.conf["activeCols"] = self.model.activeCols
|
2012-12-21 08:51:59 +01:00
|
|
|
# sorted field may have been hidden
|
|
|
|
self.setSortIndicator()
|
|
|
|
self.setColumnSizes()
|
|
|
|
self.model.endReset()
|
2013-10-04 01:43:46 +02:00
|
|
|
# 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)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setColumnSizes(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
hh = self.form.tableView.horizontalHeader()
|
2016-05-31 10:51:40 +02:00
|
|
|
hh.setSectionResizeMode(QHeaderView.Interactive)
|
2019-12-23 01:34:10 +01:00
|
|
|
hh.setSectionResizeMode(
|
|
|
|
hh.logicalIndex(len(self.model.activeCols) - 1), QHeaderView.Stretch
|
|
|
|
)
|
2013-11-25 20:57:39 +01:00
|
|
|
# this must be set post-resize or it doesn't work
|
|
|
|
hh.setCascadingSectionResizes(False)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onColumnMoved(self, *args: Any) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setColumnSizes()
|
|
|
|
|
2019-12-19 12:11:12 +01:00
|
|
|
def setupSidebar(self) -> None:
|
2020-11-17 08:42:43 +01:00
|
|
|
dw = self.sidebarDockWidget = QDockWidget(tr(TR.BROWSING_SIDEBAR), self)
|
2017-08-13 11:11:40 +02:00
|
|
|
dw.setFeatures(QDockWidget.DockWidgetClosable)
|
|
|
|
dw.setObjectName("Sidebar")
|
|
|
|
dw.setAllowedAreas(Qt.LeftDockWidgetArea)
|
2020-10-10 03:42:49 +02:00
|
|
|
|
2021-01-23 10:59:12 +01:00
|
|
|
self.sidebar = SidebarTreeView(self)
|
|
|
|
self.sidebarTree = self.sidebar # legacy alias
|
|
|
|
dw.setWidget(self.sidebar)
|
2021-02-25 11:03:57 +01:00
|
|
|
self.sidebar.toolbar = toolbar = SidebarToolbar(self.sidebar)
|
2021-01-26 23:35:40 +01:00
|
|
|
self.sidebar.searchBar = searchBar = SidebarSearchBar(self.sidebar)
|
|
|
|
qconnect(
|
2021-02-05 05:32:56 +01:00
|
|
|
self.form.actionSidebarFilter.triggered,
|
2021-01-26 23:35:40 +01:00
|
|
|
self.focusSidebarSearchBar,
|
|
|
|
)
|
2021-02-26 13:04:30 +01:00
|
|
|
grid = QGridLayout()
|
|
|
|
grid.addWidget(searchBar, 0, 0)
|
|
|
|
grid.addWidget(toolbar, 0, 1)
|
|
|
|
grid.addWidget(self.sidebar, 1, 0, 1, 2)
|
|
|
|
grid.setContentsMargins(0, 0, 0, 0)
|
|
|
|
grid.setSpacing(0)
|
2021-01-26 23:35:40 +01:00
|
|
|
w = QWidget()
|
2021-02-26 13:04:30 +01:00
|
|
|
w.setLayout(grid)
|
2021-01-26 23:35:40 +01:00
|
|
|
dw.setWidget(w)
|
2017-08-15 06:54:13 +02:00
|
|
|
self.sidebarDockWidget.setFloating(False)
|
2021-01-23 10:59:12 +01:00
|
|
|
|
2017-08-15 07:19:22 +02:00
|
|
|
self.sidebarDockWidget.setTitleBarWidget(QWidget())
|
2017-08-14 08:57:43 +02:00
|
|
|
self.addDockWidget(Qt.LeftDockWidgetArea, dw)
|
2017-08-13 11:11:40 +02:00
|
|
|
|
2021-01-23 10:59:12 +01:00
|
|
|
# schedule sidebar to refresh after browser window has loaded, so the
|
|
|
|
# UI is more responsive
|
|
|
|
self.mw.progress.timer(10, self.sidebar.refresh, False)
|
2017-08-13 11:11:40 +02:00
|
|
|
|
2021-01-26 23:35:40 +01:00
|
|
|
def showSidebar(self) -> None:
|
2020-10-24 10:47:25 +02:00
|
|
|
# workaround for PyQt focus bug
|
|
|
|
self.editor.hideCompleters()
|
2017-08-13 11:11:40 +02:00
|
|
|
self.sidebarDockWidget.setVisible(True)
|
2021-01-26 23:35:40 +01:00
|
|
|
|
|
|
|
def focusSidebar(self) -> None:
|
|
|
|
self.showSidebar()
|
2021-01-23 10:59:12 +01:00
|
|
|
self.sidebar.setFocus()
|
2017-08-13 11:11:40 +02:00
|
|
|
|
2021-01-26 23:35:40 +01:00
|
|
|
def focusSidebarSearchBar(self) -> None:
|
|
|
|
self.showSidebar()
|
|
|
|
self.sidebar.searchBar.setFocus()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def toggle_sidebar(self) -> None:
|
2021-01-23 10:59:12 +01:00
|
|
|
want_visible = not self.sidebarDockWidget.isVisible()
|
|
|
|
self.sidebarDockWidget.setVisible(want_visible)
|
|
|
|
if want_visible:
|
|
|
|
self.sidebar.refresh()
|
2020-02-15 21:03:15 +01:00
|
|
|
|
2021-01-23 10:59:12 +01:00
|
|
|
# legacy
|
2021-02-09 01:50:39 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setFilter(self, *terms: str) -> None:
|
2021-02-09 01:50:39 +01:00
|
|
|
self.sidebar.update_search(*terms)
|
2021-01-23 10:59:12 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Info
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def showCardInfo(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.card:
|
|
|
|
return
|
2020-06-15 06:14:18 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
info, cs = self._cardInfoData()
|
|
|
|
reps = self._revlogData(cs)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2020-02-12 22:12:45 +01:00
|
|
|
card_info_dialog = CardInfoDialog(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
l = QVBoxLayout()
|
2019-12-23 01:34:10 +01:00
|
|
|
l.setContentsMargins(0, 0, 0, 0)
|
2020-02-12 21:03:11 +01:00
|
|
|
w = AnkiWebView(title="browser card info")
|
2012-12-21 08:51:59 +01:00
|
|
|
l.addWidget(w)
|
2020-02-12 22:12:45 +01:00
|
|
|
w.stdHtml(info + "<p>" + reps, context=card_info_dialog)
|
2012-12-21 08:51:59 +01:00
|
|
|
bb = QDialogButtonBox(QDialogButtonBox.Close)
|
|
|
|
l.addWidget(bb)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(bb.rejected, card_info_dialog.reject)
|
2020-02-12 22:12:45 +01:00
|
|
|
card_info_dialog.setLayout(l)
|
|
|
|
card_info_dialog.setWindowModality(Qt.WindowModal)
|
|
|
|
card_info_dialog.resize(500, 400)
|
2020-02-18 01:59:24 +01:00
|
|
|
restoreGeom(card_info_dialog, "revlog")
|
2020-02-12 22:12:45 +01:00
|
|
|
card_info_dialog.show()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-06-15 06:14:18 +02:00
|
|
|
def _cardInfoData(self) -> Tuple[str, CardStats]:
|
2012-12-21 08:51:59 +01:00
|
|
|
cs = CardStats(self.col, self.card)
|
2020-06-15 06:14:18 +02:00
|
|
|
rep = cs.report(include_revlog=True)
|
2012-12-21 08:51:59 +01:00
|
|
|
return rep, cs
|
|
|
|
|
2020-06-15 06:14:18 +02:00
|
|
|
# legacy - revlog used to be generated here, and some add-ons
|
|
|
|
# wrapped this function
|
|
|
|
|
|
|
|
def _revlogData(self, cs: CardStats) -> str:
|
|
|
|
return ""
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Menu helpers
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def selectedCards(self) -> List[int]:
|
2019-12-23 01:34:10 +01:00
|
|
|
return [
|
|
|
|
self.model.cards[idx.row()]
|
|
|
|
for idx in self.form.tableView.selectionModel().selectedRows()
|
|
|
|
]
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def selectedNotes(self) -> List[int]:
|
2019-12-23 01:34:10 +01:00
|
|
|
return self.col.db.list(
|
|
|
|
"""
|
2012-12-21 08:51:59 +01:00
|
|
|
select distinct nid from cards
|
2019-12-23 01:34:10 +01:00
|
|
|
where id in %s"""
|
|
|
|
% ids2str(
|
|
|
|
[
|
|
|
|
self.model.cards[idx.row()]
|
|
|
|
for idx in self.form.tableView.selectionModel().selectedRows()
|
|
|
|
]
|
|
|
|
)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def selectedNotesAsCards(self) -> List[int]:
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.col.db.list(
|
2019-12-23 01:34:10 +01:00
|
|
|
"select id from cards where nid in (%s)"
|
|
|
|
% ",".join([str(s) for s in self.selectedNotes()])
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def oneModelNotes(self) -> List[int]:
|
2012-12-21 08:51:59 +01:00
|
|
|
sf = self.selectedNotes()
|
|
|
|
if not sf:
|
2021-02-01 00:39:55 +01:00
|
|
|
return []
|
2019-12-23 01:34:10 +01:00
|
|
|
mods = self.col.db.scalar(
|
|
|
|
"""
|
2012-12-21 08:51:59 +01:00
|
|
|
select count(distinct mid) from notes
|
2019-12-23 01:34:10 +01:00
|
|
|
where id in %s"""
|
|
|
|
% ids2str(sf)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
if mods > 1:
|
2020-11-17 08:42:43 +01:00
|
|
|
showInfo(tr(TR.BROWSING_PLEASE_SELECT_CARDS_FROM_ONLY_ONE))
|
2021-02-01 00:39:55 +01:00
|
|
|
return []
|
2012-12-21 08:51:59 +01:00
|
|
|
return sf
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onHelp(self) -> None:
|
2021-01-25 14:45:47 +01:00
|
|
|
openHelp(HelpPage.BROWSING)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Misc menu options
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onChangeModel(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
nids = self.oneModelNotes()
|
|
|
|
if nids:
|
|
|
|
ChangeModel(self, nids)
|
|
|
|
|
2021-02-01 23:46:56 +01:00
|
|
|
def createFilteredDeck(self) -> None:
|
2021-02-01 08:50:19 +01:00
|
|
|
search = self.form.searchEdit.lineEdit().text()
|
2021-02-02 09:29:09 +01:00
|
|
|
if (
|
|
|
|
self.mw.col.schedVer() != 1
|
|
|
|
and self.mw.app.keyboardModifiers() & Qt.AltModifier
|
|
|
|
):
|
|
|
|
aqt.dialogs.open("DynDeckConfDialog", self.mw, search_2=search)
|
|
|
|
else:
|
|
|
|
aqt.dialogs.open("DynDeckConfDialog", self.mw, search=search)
|
2021-02-01 19:10:05 +01:00
|
|
|
|
2013-05-03 10:52:46 +02:00
|
|
|
# Preview
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onTogglePreview(self) -> None:
|
2020-03-29 21:10:30 +02:00
|
|
|
if self._previewer:
|
2020-04-02 09:35:51 +02:00
|
|
|
self._previewer.close()
|
2020-05-19 23:46:50 +02:00
|
|
|
self._on_preview_closed()
|
2013-05-03 10:52:46 +02:00
|
|
|
else:
|
2020-04-08 08:19:59 +02:00
|
|
|
self._previewer = PreviewDialog(self, self.mw, self._on_preview_closed)
|
2020-04-02 09:35:51 +02:00
|
|
|
self._previewer.open()
|
2017-08-08 08:28:53 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _renderPreview(self) -> None:
|
2020-03-29 21:10:30 +02:00
|
|
|
if self._previewer:
|
2021-01-10 02:01:24 +01:00
|
|
|
if self.singleCard:
|
|
|
|
self._previewer.render_card()
|
|
|
|
else:
|
|
|
|
self.onTogglePreview()
|
2017-08-08 08:28:53 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _cleanup_preview(self) -> None:
|
2020-03-29 21:10:30 +02:00
|
|
|
if self._previewer:
|
2020-04-02 17:34:53 +02:00
|
|
|
self._previewer.cancel_timer()
|
2020-04-10 10:42:28 +02:00
|
|
|
self._previewer.close()
|
2019-02-26 02:18:32 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _on_preview_closed(self) -> None:
|
2021-01-10 01:21:52 +01:00
|
|
|
if self.editor.web:
|
|
|
|
self.editor.web.eval("$('#previewButton').removeClass('highlighted')")
|
2020-04-08 08:19:59 +02:00
|
|
|
self._previewer = None
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Card deletion
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def deleteNotes(self) -> None:
|
2018-03-01 04:31:52 +01:00
|
|
|
focus = self.focusWidget()
|
|
|
|
if focus != self.form.tableView:
|
|
|
|
return
|
|
|
|
self._deleteNotes()
|
2016-07-14 12:23:44 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _deleteNotes(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
nids = self.selectedNotes()
|
|
|
|
if not nids:
|
|
|
|
return
|
2020-11-17 08:42:43 +01:00
|
|
|
self.mw.checkpoint(tr(TR.BROWSING_DELETE_NOTES))
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.beginReset()
|
2014-08-11 21:32:59 +02:00
|
|
|
# figure out where to place the cursor after the deletion
|
|
|
|
curRow = self.form.tableView.selectionModel().currentIndex().row()
|
2019-12-23 01:34:10 +01:00
|
|
|
selectedRows = [
|
|
|
|
i.row() for i in self.form.tableView.selectionModel().selectedRows()
|
|
|
|
]
|
2014-08-11 21:32:59 +02:00
|
|
|
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
|
2020-06-04 10:21:04 +02:00
|
|
|
self.col.remove_notes(nids)
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
2012-12-21 08:51:59 +01:00
|
|
|
if len(self.model.cards):
|
2014-08-11 21:32:59 +02:00
|
|
|
newRow = min(newRow, len(self.model.cards) - 1)
|
|
|
|
newRow = max(newRow, 0)
|
|
|
|
self.model.focusedCard = self.model.cards[newRow]
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.endReset()
|
2020-08-17 12:07:48 +02:00
|
|
|
self.mw.reset()
|
2020-11-18 00:22:27 +01:00
|
|
|
tooltip(tr(TR.BROWSING_NOTE_DELETED, count=len(nids)))
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Deck change
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def setDeck(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
from aqt.studydeck import StudyDeck
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2013-02-20 07:25:59 +01:00
|
|
|
cids = self.selectedCards()
|
|
|
|
if not cids:
|
|
|
|
return
|
2019-12-23 01:34:10 +01:00
|
|
|
did = self.mw.col.db.scalar("select did from cards where id = ?", cids[0])
|
|
|
|
current = self.mw.col.decks.get(did)["name"]
|
2012-12-21 08:51:59 +01:00
|
|
|
ret = StudyDeck(
|
2019-12-23 01:34:10 +01:00
|
|
|
self.mw,
|
|
|
|
current=current,
|
2020-11-17 08:42:43 +01:00
|
|
|
accept=tr(TR.BROWSING_MOVE_CARDS),
|
|
|
|
title=tr(TR.BROWSING_CHANGE_DECK),
|
2021-01-25 14:45:47 +01:00
|
|
|
help=HelpPage.BROWSING,
|
2019-12-23 01:34:10 +01:00
|
|
|
parent=self,
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
if not ret.name:
|
|
|
|
return
|
|
|
|
did = self.col.decks.id(ret.name)
|
|
|
|
deck = self.col.decks.get(did)
|
2019-12-23 01:34:10 +01:00
|
|
|
if deck["dyn"]:
|
2020-11-17 08:42:43 +01:00
|
|
|
showWarning(tr(TR.BROWSING_CARDS_CANT_BE_MANUALLY_MOVED_INTO))
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
self.model.beginReset()
|
2020-11-17 08:42:43 +01:00
|
|
|
self.mw.checkpoint(tr(TR.BROWSING_CHANGE_DECK))
|
2020-09-03 09:42:46 +02:00
|
|
|
self.col.set_deck(cids, did)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.endReset()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserSetDeck, context=self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Tags
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-03-05 11:47:51 +01:00
|
|
|
def add_tags_to_selected_notes(
|
2021-02-01 00:39:55 +01:00
|
|
|
self,
|
|
|
|
tags: Optional[str] = None,
|
|
|
|
) -> None:
|
2021-03-05 11:47:51 +01:00
|
|
|
"Shows prompt if tags not provided."
|
2021-03-11 22:24:24 +01:00
|
|
|
self._update_tags_of_selected_notes(
|
|
|
|
func=self.col.tags.bulk_add,
|
|
|
|
tags=tags,
|
|
|
|
prompt=tr(TR.BROWSING_ENTER_TAGS_TO_ADD),
|
2021-03-05 11:47:51 +01:00
|
|
|
)
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-03-05 11:47:51 +01:00
|
|
|
def remove_tags_from_selected_notes(self, tags: Optional[str] = None) -> None:
|
|
|
|
"Shows prompt if tags not provided."
|
2021-03-11 22:24:24 +01:00
|
|
|
self._update_tags_of_selected_notes(
|
|
|
|
func=self.col.tags.bulk_remove,
|
|
|
|
tags=tags,
|
|
|
|
prompt=tr(TR.BROWSING_ENTER_TAGS_TO_DELETE),
|
2021-03-05 11:47:51 +01:00
|
|
|
)
|
2016-07-14 12:23:44 +02:00
|
|
|
|
2021-03-05 11:47:51 +01:00
|
|
|
def _update_tags_of_selected_notes(
|
2021-02-01 00:39:55 +01:00
|
|
|
self,
|
2021-03-05 11:47:51 +01:00
|
|
|
func: Callable[[List[int], str], int],
|
2021-02-01 00:39:55 +01:00
|
|
|
tags: Optional[str],
|
|
|
|
prompt: Optional[str],
|
|
|
|
) -> None:
|
2021-03-05 11:47:51 +01:00
|
|
|
"If tags provided, prompt skipped. If tags not provided, prompt must be."
|
2012-12-21 08:51:59 +01:00
|
|
|
if tags is None:
|
2021-03-05 11:47:51 +01:00
|
|
|
(tags, ok) = getTag(self, self.col, prompt)
|
|
|
|
if not ok:
|
|
|
|
return
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.beginReset()
|
|
|
|
func(self.selectedNotes(), tags)
|
|
|
|
self.model.endReset()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserAddTags, context=self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def clearUnusedTags(self) -> None:
|
|
|
|
def on_done(fut: Future) -> None:
|
2021-01-04 05:13:20 +01:00
|
|
|
fut.result()
|
|
|
|
self.on_tag_list_update()
|
|
|
|
|
|
|
|
self.mw.taskman.run_in_background(self.col.tags.registerNotes, on_done)
|
2017-08-11 06:40:51 +02:00
|
|
|
|
2021-03-05 11:47:51 +01:00
|
|
|
addTags = add_tags_to_selected_notes
|
|
|
|
deleteTags = remove_tags_from_selected_notes
|
|
|
|
|
2017-08-12 08:08:10 +02:00
|
|
|
# Suspending
|
2012-12-21 08:51:59 +01:00
|
|
|
######################################################################
|
|
|
|
|
2021-03-04 13:14:35 +01:00
|
|
|
def current_card_is_suspended(self) -> bool:
|
2020-03-23 18:16:39 +01:00
|
|
|
return bool(self.card and self.card.queue == QUEUE_TYPE_SUSPENDED)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-03-04 13:14:35 +01:00
|
|
|
def suspend_selected_cards(self) -> None:
|
|
|
|
want_suspend = not self.current_card_is_suspended()
|
2012-12-21 08:51:59 +01:00
|
|
|
c = self.selectedCards()
|
2021-03-04 12:40:59 +01:00
|
|
|
if want_suspend:
|
2020-08-31 08:14:04 +02:00
|
|
|
self.col.sched.suspend_cards(c)
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
2020-08-31 08:14:04 +02:00
|
|
|
self.col.sched.unsuspend_cards(c)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.reset()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserSuspend, context=self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-02-10 04:15:10 +01:00
|
|
|
# Exporting
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _on_export_notes(self) -> None:
|
2020-02-10 04:15:10 +01:00
|
|
|
cids = self.selectedNotesAsCards()
|
|
|
|
if cids:
|
|
|
|
ExportDialog(self.mw, cids=cids)
|
|
|
|
|
2017-08-16 12:30:29 +02:00
|
|
|
# Flags & Marking
|
2017-08-12 08:08:10 +02:00
|
|
|
######################################################################
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onSetFlag(self, n: int) -> None:
|
2019-12-06 05:23:54 +01:00
|
|
|
if not self.card:
|
|
|
|
return
|
2020-09-27 04:31:25 +02:00
|
|
|
self.editor.saveNow(lambda: self._on_set_flag(n))
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _on_set_flag(self, n: int) -> None:
|
2018-11-12 02:11:53 +01:00
|
|
|
# flag needs toggling off?
|
2021-03-06 15:17:17 +01:00
|
|
|
if n == self.card.user_flag():
|
2018-11-12 02:11:53 +01:00
|
|
|
n = 0
|
2021-03-06 15:17:17 +01:00
|
|
|
self.col.set_user_flag_for_cards(n, self.selectedCards())
|
2017-08-12 08:08:10 +02:00
|
|
|
self.model.reset()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _updateFlagsMenu(self) -> None:
|
2021-03-06 15:17:17 +01:00
|
|
|
flag = self.card and self.card.user_flag()
|
2018-11-12 03:10:50 +01:00
|
|
|
flag = flag or 0
|
|
|
|
|
|
|
|
f = self.form
|
2019-12-23 01:34:10 +01:00
|
|
|
flagActions = [
|
|
|
|
f.actionRed_Flag,
|
|
|
|
f.actionOrange_Flag,
|
|
|
|
f.actionGreen_Flag,
|
|
|
|
f.actionBlue_Flag,
|
|
|
|
]
|
2018-11-12 03:10:50 +01:00
|
|
|
|
|
|
|
for c, act in enumerate(flagActions):
|
2019-12-23 01:34:10 +01:00
|
|
|
act.setChecked(flag == c + 1)
|
2019-02-05 05:37:07 +01:00
|
|
|
|
|
|
|
qtMenuShortcutWorkaround(self.form.menuFlag)
|
2018-11-12 03:10:50 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onMark(self, mark: bool = None) -> None:
|
2017-08-16 12:30:29 +02:00
|
|
|
if mark is None:
|
|
|
|
mark = not self.isMarked()
|
|
|
|
if mark:
|
2021-03-05 11:47:51 +01:00
|
|
|
self.add_tags_to_selected_notes(tags="marked")
|
2017-08-16 12:30:29 +02:00
|
|
|
else:
|
2021-03-05 11:47:51 +01:00
|
|
|
self.remove_tags_from_selected_notes(tags="marked")
|
2017-08-16 12:30:29 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def isMarked(self) -> bool:
|
2021-03-05 13:45:55 +01:00
|
|
|
return bool(self.card and self.card.note().has_tag("Marked"))
|
2017-08-16 12:30:29 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Repositioning
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def reposition(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
cids = self.selectedCards()
|
|
|
|
cids2 = self.col.db.list(
|
2020-01-31 09:58:03 +01:00
|
|
|
f"select id from cards where type = {CARD_TYPE_NEW} and id in "
|
|
|
|
+ ids2str(cids)
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
if not cids2:
|
2021-02-01 00:39:55 +01:00
|
|
|
showInfo(tr(TR.BROWSING_ONLY_NEW_CARDS_CAN_BE_REPOSITIONED))
|
|
|
|
return
|
2012-12-21 08:51:59 +01:00
|
|
|
d = QDialog(self)
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button(d)
|
2012-12-21 08:51:59 +01:00
|
|
|
d.setWindowModality(Qt.WindowModal)
|
|
|
|
frm = aqt.forms.reposition.Ui_Dialog()
|
|
|
|
frm.setupUi(d)
|
|
|
|
(pmin, pmax) = self.col.db.first(
|
2020-02-02 10:19:45 +01:00
|
|
|
f"select min(due), max(due) from cards where type={CARD_TYPE_NEW} and odid=0"
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2014-01-14 07:06:22 +01:00
|
|
|
pmin = pmin or 0
|
|
|
|
pmax = pmax or 0
|
2020-11-17 12:47:47 +01:00
|
|
|
txt = tr(TR.BROWSING_QUEUE_TOP, val=pmin)
|
|
|
|
txt += "\n" + tr(TR.BROWSING_QUEUE_BOTTOM, val=pmax)
|
2012-12-21 08:51:59 +01:00
|
|
|
frm.label.setText(txt)
|
2020-11-03 02:07:53 +01:00
|
|
|
frm.start.selectAll()
|
2012-12-21 08:51:59 +01:00
|
|
|
if not d.exec_():
|
|
|
|
return
|
|
|
|
self.model.beginReset()
|
2020-11-17 08:42:43 +01:00
|
|
|
self.mw.checkpoint(tr(TR.ACTIONS_REPOSITION))
|
2012-12-21 08:51:59 +01:00
|
|
|
self.col.sched.sortCards(
|
2019-12-23 01:34:10 +01:00
|
|
|
cids,
|
|
|
|
start=frm.start.value(),
|
|
|
|
step=frm.step.value(),
|
|
|
|
shuffle=frm.randomize.isChecked(),
|
|
|
|
shift=frm.shift.isChecked(),
|
|
|
|
)
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserReposition, context=self)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.endReset()
|
|
|
|
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
# Scheduling
|
2012-12-21 08:51:59 +01:00
|
|
|
######################################################################
|
|
|
|
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
def _after_schedule(self) -> None:
|
|
|
|
self.model.reset()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserReschedule, context=self)
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
def set_due_date(self) -> None:
|
2021-03-11 22:24:24 +01:00
|
|
|
set_due_date_dialog(
|
|
|
|
mw=self.mw,
|
|
|
|
parent=self,
|
|
|
|
card_ids=self.selectedCards(),
|
|
|
|
default_key=Config.String.SET_DUE_BROWSER,
|
|
|
|
on_done=self._after_schedule,
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
)
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
def forget_cards(self) -> None:
|
2021-03-11 22:24:24 +01:00
|
|
|
forget_cards(
|
|
|
|
mw=self.mw,
|
|
|
|
parent=self,
|
|
|
|
card_ids=self.selectedCards(),
|
|
|
|
on_done=self._after_schedule,
|
Rework reschedule tool
The old rescheduling dialog's two options have been split into two
separate menu items, "Forget", and "Set Due Date"
For cards that are not review cards, "Set Due Date" behaves like the
old reschedule option, changing the cards into a review card, and
and setting both the interval and due date to the provided number of
days.
When "Set Due Date" is applied to a review card, it no longer resets
the card's interval. Instead, it looks at how much the provided number
of days will change the original interval, and adjusts the interval by
that amount, so that cards that are answered earlier receive a smaller
next interval, and cards that are answered after a longer delay receive
a bonus.
For example, imagine a card was answered on day 5, and given an interval
of 10 days, so it has a due date of day 15.
- if on day 10 the due date is changed to day 12 (today+2), the card
is being scheduled 3 days earlier than it was supposed to be, so the
interval will be adjusted to 7 days.
- and if on day 10 the due date is changed to day 20, the interval will
be changed from 10 days to 15 days.
There is no separate option to reset the interval of a review card, but
it can be accomplished by forgetting the card(s), and then setting the
desired due date.
Other notes:
- Added the action to the review screen as well.
- Set the shortcut to Ctrl+Shift+D, and changed the existing Delete
Tags shortcut to Ctrl+Alt+Shift+A.
2021-02-07 11:58:16 +01:00
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Edit: selection
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def selectNotes(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
nids = self.selectedNotes()
|
|
|
|
# clear the selection so we don't waste energy preserving it
|
|
|
|
tv = self.form.tableView
|
|
|
|
tv.selectionModel().clear()
|
2020-10-19 20:51:36 +02:00
|
|
|
|
2021-01-30 02:23:32 +01:00
|
|
|
search = self.col.build_search_string(
|
2021-02-11 10:57:19 +01:00
|
|
|
SearchNode(nids=SearchNode.IdList(ids=nids))
|
2021-01-30 02:23:32 +01:00
|
|
|
)
|
2020-10-19 20:51:36 +02:00
|
|
|
self.search_for(search)
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
tv.selectAll()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def invertSelection(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
sm = self.form.tableView.selectionModel()
|
|
|
|
items = sm.selection()
|
|
|
|
self.form.tableView.selectAll()
|
|
|
|
sm.select(items, QItemSelectionModel.Deselect | QItemSelectionModel.Rows)
|
|
|
|
|
2020-01-15 22:53:12 +01:00
|
|
|
# Hooks
|
2012-12-21 08:51:59 +01:00
|
|
|
######################################################################
|
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def setupHooks(self) -> None:
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.undo_state_did_change.append(self.onUndoState)
|
|
|
|
gui_hooks.state_did_reset.append(self.onReset)
|
2020-01-15 08:45:35 +01:00
|
|
|
gui_hooks.editor_did_fire_typing_timer.append(self.refreshCurrentCard)
|
|
|
|
gui_hooks.editor_did_load_note.append(self.onLoadNote)
|
2020-01-15 22:53:12 +01:00
|
|
|
gui_hooks.editor_did_unfocus_field.append(self.on_unfocus_field)
|
2020-05-22 02:47:14 +02:00
|
|
|
gui_hooks.sidebar_should_refresh_decks.append(self.on_item_added)
|
|
|
|
gui_hooks.sidebar_should_refresh_notetypes.append(self.on_item_added)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def teardownHooks(self) -> None:
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.undo_state_did_change.remove(self.onUndoState)
|
|
|
|
gui_hooks.state_did_reset.remove(self.onReset)
|
2020-01-15 08:45:35 +01:00
|
|
|
gui_hooks.editor_did_fire_typing_timer.remove(self.refreshCurrentCard)
|
|
|
|
gui_hooks.editor_did_load_note.remove(self.onLoadNote)
|
2020-01-15 22:53:12 +01:00
|
|
|
gui_hooks.editor_did_unfocus_field.remove(self.on_unfocus_field)
|
2020-05-22 02:47:14 +02:00
|
|
|
gui_hooks.sidebar_should_refresh_decks.remove(self.on_item_added)
|
|
|
|
gui_hooks.sidebar_should_refresh_notetypes.remove(self.on_item_added)
|
2020-01-15 22:53:12 +01:00
|
|
|
|
2020-01-15 23:53:28 +01:00
|
|
|
def on_unfocus_field(self, changed: bool, note: Note, field_idx: int) -> None:
|
2020-01-15 22:53:12 +01:00
|
|
|
self.refreshCurrentCard(note)
|
|
|
|
|
|
|
|
# covers the tag, note and deck case
|
2020-05-22 02:47:14 +02:00
|
|
|
def on_item_added(self, item: Any = None) -> None:
|
2021-01-23 10:59:12 +01:00
|
|
|
self.sidebar.refresh()
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def on_tag_list_update(self) -> None:
|
2021-01-23 10:59:12 +01:00
|
|
|
self.sidebar.refresh()
|
2020-04-03 11:30:42 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onUndoState(self, on: bool) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.actionUndo.setEnabled(on)
|
|
|
|
if on:
|
|
|
|
self.form.actionUndo.setText(self.mw.form.actionUndo.text())
|
|
|
|
|
|
|
|
# Edit: replacing
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFindReplace(self) -> None:
|
2020-05-05 14:14:12 +02:00
|
|
|
nids = self.selectedNotes()
|
|
|
|
if not nids:
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
|
|
|
import anki.find
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def find() -> List[str]:
|
2020-05-05 14:14:12 +02:00
|
|
|
return anki.find.fieldNamesForNotes(self.mw.col, nids)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def on_done(fut: Future) -> None:
|
2020-05-05 14:14:12 +02:00
|
|
|
self._on_find_replace_diag(fut.result(), nids)
|
|
|
|
|
|
|
|
self.mw.taskman.with_progress(find, on_done, self)
|
|
|
|
|
|
|
|
def _on_find_replace_diag(self, fields: List[str], nids: List[int]) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
d = QDialog(self)
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button(d)
|
2012-12-21 08:51:59 +01:00
|
|
|
frm = aqt.forms.findreplace.Ui_Dialog()
|
|
|
|
frm.setupUi(d)
|
|
|
|
d.setWindowModality(Qt.WindowModal)
|
2020-05-31 05:04:21 +02:00
|
|
|
|
2020-05-31 05:39:00 +02:00
|
|
|
combo = "BrowserFindAndReplace"
|
2020-06-05 03:39:53 +02:00
|
|
|
findhistory = restore_combo_history(frm.find, combo + "Find")
|
2020-08-09 04:10:34 +02:00
|
|
|
frm.find.completer().setCaseSensitivity(True)
|
2020-06-05 03:39:53 +02:00
|
|
|
replacehistory = restore_combo_history(frm.replace, combo + "Replace")
|
2020-08-09 04:10:34 +02:00
|
|
|
frm.replace.completer().setCaseSensitivity(True)
|
2020-05-31 05:18:51 +02:00
|
|
|
|
2020-06-05 03:39:53 +02:00
|
|
|
restore_is_checked(frm.re, combo + "Regex")
|
|
|
|
restore_is_checked(frm.ignoreCase, combo + "ignoreCase")
|
2020-05-31 05:57:11 +02:00
|
|
|
|
2020-05-31 05:39:00 +02:00
|
|
|
frm.find.setFocus()
|
2020-11-17 08:42:43 +01:00
|
|
|
allfields = [tr(TR.BROWSING_ALL_FIELDS)] + fields
|
2020-05-31 21:52:58 +02:00
|
|
|
frm.field.addItems(allfields)
|
2020-06-08 20:54:20 +02:00
|
|
|
restore_combo_index_for_session(frm.field, allfields, combo + "Field")
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(frm.buttonBox.helpRequested, self.onFindReplaceHelp)
|
2014-06-18 20:47:45 +02:00
|
|
|
restoreGeom(d, "findreplace")
|
|
|
|
r = d.exec_()
|
|
|
|
saveGeom(d, "findreplace")
|
|
|
|
if not r:
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
2020-05-31 21:52:58 +02:00
|
|
|
|
2020-06-08 20:54:20 +02:00
|
|
|
save_combo_index_for_session(frm.field, combo + "Field")
|
2012-12-21 08:51:59 +01:00
|
|
|
if frm.field.currentIndex() == 0:
|
|
|
|
field = None
|
|
|
|
else:
|
2019-12-23 01:34:10 +01:00
|
|
|
field = fields[frm.field.currentIndex() - 1]
|
2020-05-05 14:14:12 +02:00
|
|
|
|
2020-06-05 03:39:53 +02:00
|
|
|
search = save_combo_history(frm.find, findhistory, combo + "Find")
|
|
|
|
replace = save_combo_history(frm.replace, replacehistory, combo + "Replace")
|
2020-05-31 05:18:51 +02:00
|
|
|
|
2020-05-05 14:14:12 +02:00
|
|
|
regex = frm.re.isChecked()
|
|
|
|
nocase = frm.ignoreCase.isChecked()
|
|
|
|
|
2020-06-05 03:39:53 +02:00
|
|
|
save_is_checked(frm.re, combo + "Regex")
|
|
|
|
save_is_checked(frm.ignoreCase, combo + "ignoreCase")
|
2020-05-31 05:57:11 +02:00
|
|
|
|
2020-11-17 08:42:43 +01:00
|
|
|
self.mw.checkpoint(tr(TR.BROWSING_FIND_AND_REPLACE))
|
2020-05-05 14:14:12 +02:00
|
|
|
# starts progress dialog as well
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.beginReset()
|
2020-05-05 14:14:12 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def do_search() -> int:
|
2020-05-06 01:25:23 +02:00
|
|
|
return self.col.find_and_replace(
|
|
|
|
nids, search, replace, regex, field, nocase
|
|
|
|
)
|
2020-05-05 14:14:12 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def on_done(fut: Future) -> None:
|
2016-07-14 12:23:44 +02:00
|
|
|
self.search()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserFindReplace, context=self)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.model.endReset()
|
2020-05-05 14:14:12 +02:00
|
|
|
|
|
|
|
total = len(nids)
|
|
|
|
try:
|
|
|
|
changed = fut.result()
|
|
|
|
except InvalidInput as e:
|
2021-01-16 06:37:40 +01:00
|
|
|
show_invalid_search_error(e)
|
2020-05-05 14:14:12 +02:00
|
|
|
return
|
|
|
|
|
|
|
|
showInfo(
|
|
|
|
tr(TR.FINDREPLACE_NOTES_UPDATED, changed=changed, total=total),
|
|
|
|
parent=self,
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2020-05-05 14:14:12 +02:00
|
|
|
|
|
|
|
self.mw.taskman.run_in_background(do_search, on_done)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFindReplaceHelp(self) -> None:
|
2021-01-25 14:45:47 +01:00
|
|
|
openHelp(HelpPage.BROWSING_FIND_AND_REPLACE)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
|
|
|
# Edit: finding dupes
|
|
|
|
######################################################################
|
|
|
|
|
2021-03-11 22:24:24 +01:00
|
|
|
@save_editor
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFindDupes(self) -> None:
|
2020-02-11 23:28:21 +01:00
|
|
|
d = QDialog(self)
|
2021-03-05 04:07:52 +01:00
|
|
|
self.mw.garbage_collect_on_dialog_finish(d)
|
2012-12-21 08:51:59 +01:00
|
|
|
frm = aqt.forms.finddupes.Ui_Dialog()
|
|
|
|
frm.setupUi(d)
|
|
|
|
restoreGeom(d, "findDupes")
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button(d)
|
2020-06-05 03:39:53 +02:00
|
|
|
searchHistory = restore_combo_history(frm.search, "findDupesFind")
|
2020-05-31 22:10:09 +02:00
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
fields = sorted(
|
|
|
|
anki.find.fieldNames(self.col, downcase=False), key=lambda x: x.lower()
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
frm.fields.addItems(fields)
|
2020-06-08 20:54:20 +02:00
|
|
|
restore_combo_index_for_session(frm.fields, fields, "findDupesFields")
|
2013-10-03 17:07:11 +02:00
|
|
|
self._dupesButton = None
|
2020-05-31 23:37:10 +02:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# links
|
2020-02-12 21:03:11 +01:00
|
|
|
frm.webView.title = "find duplicates"
|
2020-02-12 22:00:13 +01:00
|
|
|
web_context = FindDupesDialog(dialog=d, browser=self)
|
|
|
|
frm.webView.set_bridge_command(self.dupeLinkClicked, web_context)
|
|
|
|
frm.webView.stdHtml("", context=web_context)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFin(code: Any) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
saveGeom(d, "findDupes")
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(d.finished, onFin)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onClick() -> None:
|
2020-06-05 03:39:53 +02:00
|
|
|
search_text = save_combo_history(frm.search, searchHistory, "findDupesFind")
|
2020-06-08 20:54:20 +02:00
|
|
|
save_combo_index_for_session(frm.fields, "findDupesFields")
|
2012-12-21 08:51:59 +01:00
|
|
|
field = fields[frm.fields.currentIndex()]
|
2020-05-31 22:10:09 +02:00
|
|
|
self.duplicatesReport(frm.webView, field, search_text, frm, web_context)
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2020-11-17 08:42:43 +01:00
|
|
|
search = frm.buttonBox.addButton(
|
|
|
|
tr(TR.ACTIONS_SEARCH), QDialogButtonBox.ActionRole
|
|
|
|
)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(search.clicked, onClick)
|
2012-12-21 08:51:59 +01:00
|
|
|
d.show()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def duplicatesReport(
|
|
|
|
self,
|
|
|
|
web: AnkiWebView,
|
|
|
|
fname: str,
|
|
|
|
search: str,
|
|
|
|
frm: aqt.forms.finddupes.Ui_Dialog,
|
|
|
|
web_context: FindDupesDialog,
|
|
|
|
) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.mw.progress.start()
|
2021-01-28 19:49:16 +01:00
|
|
|
try:
|
|
|
|
res = self.mw.col.findDupes(fname, search)
|
|
|
|
except InvalidInput as e:
|
|
|
|
self.mw.progress.finish()
|
|
|
|
show_invalid_search_error(e)
|
|
|
|
return
|
2013-10-03 17:07:11 +02:00
|
|
|
if not self._dupesButton:
|
|
|
|
self._dupesButton = b = frm.buttonBox.addButton(
|
2020-11-17 08:42:43 +01:00
|
|
|
tr(TR.BROWSING_TAG_DUPLICATES), QDialogButtonBox.ActionRole
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(b.clicked, lambda: self._onTagDupes(res))
|
2020-02-11 23:28:33 +01:00
|
|
|
t = ""
|
2012-12-21 08:51:59 +01:00
|
|
|
groups = len(res)
|
|
|
|
notes = sum(len(r[1]) for r in res)
|
2020-11-18 00:22:27 +01:00
|
|
|
part1 = tr(TR.BROWSING_GROUP, count=groups)
|
|
|
|
part2 = tr(TR.BROWSING_NOTE_COUNT, count=notes)
|
2020-11-22 05:57:53 +01:00
|
|
|
t += tr(TR.BROWSING_FOUND_AS_ACROSS_BS, part=part1, whole=part2)
|
2012-12-21 08:51:59 +01:00
|
|
|
t += "<p><ol>"
|
|
|
|
for val, nids in res:
|
2019-12-23 01:34:10 +01:00
|
|
|
t += (
|
|
|
|
"""<li><a href=# onclick="pycmd('%s');return false;">%s</a>: %s</a>"""
|
|
|
|
% (
|
2021-01-30 02:23:32 +01:00
|
|
|
html.escape(
|
|
|
|
self.col.build_search_string(
|
2021-02-11 10:57:19 +01:00
|
|
|
SearchNode(nids=SearchNode.IdList(ids=nids))
|
2021-01-30 02:23:32 +01:00
|
|
|
)
|
|
|
|
),
|
2020-11-18 00:22:27 +01:00
|
|
|
tr(TR.BROWSING_NOTE_COUNT, count=len(nids)),
|
2019-12-23 01:34:10 +01:00
|
|
|
html.escape(val),
|
|
|
|
)
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
t += "</ol>"
|
2020-02-12 22:00:13 +01:00
|
|
|
web.stdHtml(t, context=web_context)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.mw.progress.finish()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _onTagDupes(self, res: List[Any]) -> None:
|
2013-10-03 17:07:11 +02:00
|
|
|
if not res:
|
|
|
|
return
|
|
|
|
self.model.beginReset()
|
2020-11-17 08:42:43 +01:00
|
|
|
self.mw.checkpoint(tr(TR.BROWSING_TAG_DUPLICATES))
|
2013-10-03 17:07:11 +02:00
|
|
|
nids = set()
|
2021-01-08 20:53:27 +01:00
|
|
|
for _, nidlist in res:
|
2013-10-03 17:07:11 +02:00
|
|
|
nids.update(nidlist)
|
2021-03-05 11:47:51 +01:00
|
|
|
self.col.tags.bulk_add(list(nids), tr(TR.BROWSING_DUPLICATE))
|
2013-10-03 17:07:11 +02:00
|
|
|
self.mw.progress.finish()
|
|
|
|
self.model.endReset()
|
2020-08-16 18:49:51 +02:00
|
|
|
self.mw.requireReset(reason=ResetReason.BrowserTagDupes, context=self)
|
2020-11-17 08:42:43 +01:00
|
|
|
tooltip(tr(TR.BROWSING_NOTES_TAGGED))
|
2013-10-03 17:07:11 +02:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def dupeLinkClicked(self, link: str) -> None:
|
2020-10-19 20:51:36 +02:00
|
|
|
self.search_for(link)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.onNote()
|
|
|
|
|
|
|
|
# Jumping
|
|
|
|
######################################################################
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _moveCur(self, dir: int, idx: QModelIndex = None) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.model.cards:
|
|
|
|
return
|
|
|
|
tv = self.form.tableView
|
|
|
|
if idx is None:
|
|
|
|
idx = tv.moveCursor(dir, self.mw.app.keyboardModifiers())
|
2017-08-05 07:15:19 +02:00
|
|
|
tv.selectionModel().setCurrentIndex(
|
|
|
|
idx,
|
2019-12-23 01:34:10 +01:00
|
|
|
QItemSelectionModel.Clear
|
|
|
|
| QItemSelectionModel.Select
|
|
|
|
| QItemSelectionModel.Rows,
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onPreviousCard(self) -> None:
|
2017-08-05 07:15:19 +02:00
|
|
|
self.focusTo = self.editor.currentField
|
2016-07-14 12:23:44 +02:00
|
|
|
self.editor.saveNow(self._onPreviousCard)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _onPreviousCard(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self._moveCur(QAbstractItemView.MoveUp)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onNextCard(self) -> None:
|
2017-08-05 07:15:19 +02:00
|
|
|
self.focusTo = self.editor.currentField
|
2016-07-14 12:23:44 +02:00
|
|
|
self.editor.saveNow(self._onNextCard)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def _onNextCard(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self._moveCur(QAbstractItemView.MoveDown)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFirstCard(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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)
|
2019-12-23 01:34:10 +01:00
|
|
|
sm.select(item, QItemSelectionModel.SelectCurrent | QItemSelectionModel.Rows)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onLastCard(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
sm = self.form.tableView.selectionModel()
|
|
|
|
idx = sm.currentIndex()
|
2019-12-23 01:34:10 +01:00
|
|
|
self._moveCur(None, self.model.index(len(self.model.cards) - 1, 0))
|
2012-12-21 08:51:59 +01:00
|
|
|
if not self.mw.app.keyboardModifiers() & Qt.ShiftModifier:
|
|
|
|
return
|
|
|
|
idx2 = sm.currentIndex()
|
|
|
|
item = QItemSelection(idx, idx2)
|
2019-12-23 01:34:10 +01:00
|
|
|
sm.select(item, QItemSelectionModel.SelectCurrent | QItemSelectionModel.Rows)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onFind(self) -> None:
|
2020-10-24 10:47:25 +02:00
|
|
|
# workaround for PyQt focus bug
|
|
|
|
self.editor.hideCompleters()
|
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.searchEdit.setFocus()
|
|
|
|
self.form.searchEdit.lineEdit().selectAll()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onNote(self) -> None:
|
2020-10-24 10:47:25 +02:00
|
|
|
# workaround for PyQt focus bug
|
|
|
|
self.editor.hideCompleters()
|
|
|
|
|
2013-01-29 01:49:04 +01:00
|
|
|
self.editor.web.setFocus()
|
2019-12-06 05:22:49 +01:00
|
|
|
self.editor.loadNote(focusTo=0)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onCardList(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.tableView.setFocus()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def focusCid(self, cid: int) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
try:
|
2021-01-30 13:15:46 +01:00
|
|
|
row = list(self.model.cards).index(cid)
|
|
|
|
except ValueError:
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
2021-01-30 10:51:31 +01:00
|
|
|
self.form.tableView.clearSelection()
|
2012-12-21 08:51:59 +01:00
|
|
|
self.form.tableView.selectRow(row)
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
# Change model dialog
|
|
|
|
######################################################################
|
|
|
|
|
|
|
|
|
2019-12-23 01:34:10 +01:00
|
|
|
class ChangeModel(QDialog):
|
2021-02-01 00:39:55 +01:00
|
|
|
def __init__(self, browser: Browser, nids: List[int]) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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)
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.setWindowModality(Qt.WindowModal)
|
|
|
|
self.setup()
|
|
|
|
restoreGeom(self, "changeModel")
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_did_reset.append(self.onReset)
|
2020-01-15 22:53:12 +01:00
|
|
|
gui_hooks.current_note_type_did_change.append(self.on_note_type_change)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.exec_()
|
|
|
|
|
2020-01-15 22:53:12 +01:00
|
|
|
def on_note_type_change(self, notetype: NoteType) -> None:
|
|
|
|
self.onReset()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def setup(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
# maps
|
|
|
|
self.flayout = QHBoxLayout()
|
2019-12-23 01:34:10 +01:00
|
|
|
self.flayout.setContentsMargins(0, 0, 0, 0)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.fwidg = None
|
|
|
|
self.form.fieldMap.setLayout(self.flayout)
|
|
|
|
self.tlayout = QHBoxLayout()
|
2019-12-23 01:34:10 +01:00
|
|
|
self.tlayout.setContentsMargins(0, 0, 0, 0)
|
2012-12-21 08:51:59 +01:00
|
|
|
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
|
2019-12-23 01:34:10 +01:00
|
|
|
|
2012-12-21 08:51:59 +01:00
|
|
|
self.oldModel = self.browser.col.models.get(
|
|
|
|
self.browser.col.db.scalar(
|
2019-12-23 01:34:10 +01:00
|
|
|
"select mid from notes where id = ?", self.nids[0]
|
|
|
|
)
|
|
|
|
)
|
|
|
|
self.form.oldModelLabel.setText(self.oldModel["name"])
|
2012-12-21 08:51:59 +01:00
|
|
|
self.modelChooser = aqt.modelchooser.ModelChooser(
|
2019-12-23 01:34:10 +01:00
|
|
|
self.browser.mw, self.form.modelChooserWidget, label=False
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.modelChooser.models.setFocus()
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(self.form.buttonBox.helpRequested, self.onHelp)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.modelChanged(self.browser.mw.col.models.current())
|
|
|
|
self.pauseUpdate = False
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onReset(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.modelChanged(self.browser.col.models.current())
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def modelChanged(self, model: Dict[str, Any]) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.targetModel = model
|
|
|
|
self.rebuildTemplateMap()
|
|
|
|
self.rebuildFieldMap()
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def rebuildTemplateMap(
|
|
|
|
self, key: Optional[str] = None, attr: Optional[str] = None
|
|
|
|
) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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 = []
|
2020-11-17 08:42:43 +01:00
|
|
|
targets = [x["name"] for x in dst] + [tr(TR.BROWSING_NOTHING)]
|
2012-12-21 08:51:59 +01:00
|
|
|
indices = {}
|
|
|
|
for i, x in enumerate(src):
|
2020-11-17 12:47:47 +01:00
|
|
|
l.addWidget(QLabel(tr(TR.BROWSING_CHANGE_TO, val=x["name"])), i, 0)
|
2012-12-21 08:51:59 +01:00
|
|
|
cb = QComboBox()
|
|
|
|
cb.addItems(targets)
|
2019-12-23 01:34:10 +01:00
|
|
|
idx = min(i, len(targets) - 1)
|
2012-12-21 08:51:59 +01:00
|
|
|
cb.setCurrentIndex(idx)
|
|
|
|
indices[cb] = idx
|
2020-05-04 05:23:08 +02:00
|
|
|
qconnect(
|
|
|
|
cb.currentIndexChanged,
|
|
|
|
lambda i, cb=cb, key=key: self.onComboChanged(i, cb, key),
|
2019-12-23 01:34:10 +01:00
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
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)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def rebuildFieldMap(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.rebuildTemplateMap(key="f", attr="flds")
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onComboChanged(self, i: int, cb: QComboBox, key: str) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
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
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def getTemplateMap(
|
|
|
|
self,
|
|
|
|
old: Optional[List[Dict[str, Any]]] = None,
|
|
|
|
combos: Optional[List[QComboBox]] = None,
|
|
|
|
new: Optional[List[Dict[str, Any]]] = None,
|
|
|
|
) -> Dict[int, Optional[int]]:
|
2012-12-21 08:51:59 +01:00
|
|
|
if not old:
|
2019-12-23 01:34:10 +01:00
|
|
|
old = self.oldModel["tmpls"]
|
2012-12-21 08:51:59 +01:00
|
|
|
combos = self.tcombos
|
2019-12-23 01:34:10 +01:00
|
|
|
new = self.targetModel["tmpls"]
|
2020-07-26 01:25:39 +02:00
|
|
|
template_map: Dict[int, Optional[int]] = {}
|
2012-12-21 08:51:59 +01:00
|
|
|
for i, f in enumerate(old):
|
|
|
|
idx = combos[i].currentIndex()
|
|
|
|
if idx == len(new):
|
|
|
|
# ignore
|
2020-07-26 01:25:39 +02:00
|
|
|
template_map[f["ord"]] = None
|
2012-12-21 08:51:59 +01:00
|
|
|
else:
|
|
|
|
f2 = new[idx]
|
2020-07-26 01:25:39 +02:00
|
|
|
template_map[f["ord"]] = f2["ord"]
|
|
|
|
return template_map
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def getFieldMap(self) -> Dict[int, Optional[int]]:
|
2012-12-21 08:51:59 +01:00
|
|
|
return self.getTemplateMap(
|
2019-12-23 01:34:10 +01:00
|
|
|
old=self.oldModel["flds"], combos=self.fcombos, new=self.targetModel["flds"]
|
|
|
|
)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2020-01-15 22:41:23 +01:00
|
|
|
def cleanup(self) -> None:
|
2020-01-15 07:53:24 +01:00
|
|
|
gui_hooks.state_did_reset.remove(self.onReset)
|
2020-01-15 22:53:12 +01:00
|
|
|
gui_hooks.current_note_type_did_change.remove(self.on_note_type_change)
|
2012-12-21 08:51:59 +01:00
|
|
|
self.modelChooser.cleanup()
|
|
|
|
saveGeom(self, "changeModel")
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def reject(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
self.cleanup()
|
|
|
|
return QDialog.reject(self)
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def accept(self) -> None:
|
2012-12-21 08:51:59 +01:00
|
|
|
# check maps
|
|
|
|
fmap = self.getFieldMap()
|
|
|
|
cmap = self.getTemplateMap()
|
2016-05-12 06:45:35 +02:00
|
|
|
if any(True for c in list(cmap.values()) if c is None):
|
2020-11-18 02:32:22 +01:00
|
|
|
if not askUser(tr(TR.BROWSING_ANY_CARDS_MAPPED_TO_NOTHING_WILL)):
|
2012-12-21 08:51:59 +01:00
|
|
|
return
|
2020-11-17 08:42:43 +01:00
|
|
|
self.browser.mw.checkpoint(tr(TR.BROWSING_CHANGE_NOTE_TYPE))
|
2012-12-21 08:51:59 +01:00
|
|
|
b = self.browser
|
2016-07-14 13:49:40 +02:00
|
|
|
b.mw.col.modSchema(check=True)
|
|
|
|
b.mw.progress.start()
|
2012-12-21 08:51:59 +01:00
|
|
|
b.model.beginReset()
|
|
|
|
mm = b.mw.col.models
|
|
|
|
mm.change(self.oldModel, self.nids, self.targetModel, fmap, cmap)
|
2016-07-14 12:23:44 +02:00
|
|
|
b.search()
|
2012-12-21 08:51:59 +01:00
|
|
|
b.model.endReset()
|
|
|
|
b.mw.progress.finish()
|
|
|
|
b.mw.reset()
|
|
|
|
self.cleanup()
|
make sure change note type clears up hooks
if an error occurred after QDialog.accept() had been called,
the hook was left lying around and caused errors when reset later
fired
File "aqt\main.py", line 1028, in onCheckDB
File "aqt\main.py", line 516, in reset
File "anki\hooks.py", line 28, in runHook
File "aqt\modelchooser.py", line 47, in onReset
File "aqt\modelchooser.py", line 82, in updateModels
<class 'RuntimeError'>: wrapped C/C++ object of type QPushButton has been deleted
2018-12-15 03:45:17 +01:00
|
|
|
QDialog.accept(self)
|
2012-12-21 08:51:59 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def onHelp(self) -> None:
|
2021-01-25 14:45:47 +01:00
|
|
|
openHelp(HelpPage.BROWSING_OTHER_MENU_ITEMS)
|
2020-02-12 22:12:45 +01:00
|
|
|
|
|
|
|
|
|
|
|
# Card Info Dialog
|
|
|
|
######################################################################
|
|
|
|
|
2020-02-12 22:15:44 +01:00
|
|
|
|
2020-02-12 22:12:45 +01:00
|
|
|
class CardInfoDialog(QDialog):
|
|
|
|
silentlyClose = True
|
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def __init__(self, browser: Browser) -> None:
|
|
|
|
super().__init__(browser)
|
2020-02-12 22:12:45 +01:00
|
|
|
self.browser = browser
|
2021-01-07 05:24:49 +01:00
|
|
|
disable_help_button(self)
|
2020-02-12 22:12:45 +01:00
|
|
|
|
2021-02-01 00:39:55 +01:00
|
|
|
def reject(self) -> None:
|
2020-02-12 22:12:45 +01:00
|
|
|
saveGeom(self, "revlog")
|
|
|
|
return QDialog.reject(self)
|